@javascriptcommon/react-native-webview 13.12.16

package/windows/ReactNativeWebView/ReactWebView2Manager.cpp

@@ -0,0 +1,205 @@
+#include "pch.h"
+#include "ReactWebView2Manager.h"
+
+#if HAS_WEBVIEW2
+#include "NativeModules.h"
+#include "ReactWebView2.h"
+#include "JSValueXaml.h"
+
+namespace mux {
+    using namespace winrt::Microsoft::UI::Xaml::Controls;
+}
+
+namespace winrt {
+    using namespace Microsoft::ReactNative;
+    using namespace Windows::Foundation;
+    using namespace Windows::Foundation::Collections;
+    using namespace Windows::Web::Http;
+    using namespace Windows::Web::Http::Headers;
+    using namespace xaml;
+    using namespace xaml::Controls;
+    using namespace xaml::Input;
+}
+
+namespace winrt::ReactNativeWebView::implementation {
+
+    ReactWebView2Manager::ReactWebView2Manager() {}
+
+    // IViewManager
+    winrt::hstring ReactWebView2Manager::Name() noexcept {
+        return L"RCTWebView2";
+    }
+
+    winrt::FrameworkElement ReactWebView2Manager::CreateView() noexcept {
+        auto view = winrt::ReactNativeWebView::ReactWebView2(m_reactContext);
+        return view;
+    }
+
+    // IViewManagerWithReactContext
+    winrt::IReactContext ReactWebView2Manager::ReactContext() noexcept {
+        return m_reactContext;
+    }
+
+    void ReactWebView2Manager::ReactContext(IReactContext reactContext) noexcept {
+        m_reactContext = reactContext;
+    }
+
+    // IViewManagerWithNativeProperties
+    IMapView<hstring, ViewManagerPropertyType> ReactWebView2Manager::NativeProps() noexcept {
+        auto nativeProps = winrt::single_threaded_map<hstring, ViewManagerPropertyType>();
+        nativeProps.Insert(L"source", ViewManagerPropertyType::Map);
+        nativeProps.Insert(L"messagingEnabled", ViewManagerPropertyType::Boolean);
+        nativeProps.Insert(L"injectedJavaScript", ViewManagerPropertyType::String);
+        nativeProps.Insert(L"linkHandlingEnabled", ViewManagerPropertyType::String);
+        return nativeProps.GetView();
+    }
+
+    void ReactWebView2Manager::UpdateProperties(
+        FrameworkElement const& view,
+        IJSValueReader const& propertyMapReader) noexcept {
+        auto control = view.as<winrt::ContentPresenter>();
+        auto content = control.Content();
+        auto webView = content.as<mux::WebView2>();
+        const JSValueObject& propertyMap = JSValueObject::ReadFrom(propertyMapReader);
+
+        for (auto const& pair : propertyMap) {
+            auto const& propertyName = pair.first;
+            auto const& propertyValue = pair.second;
+            if (propertyValue.IsNull()) continue;
+
+            if (propertyName == "source") {
+                auto const& srcMap = propertyValue.AsObject();
+                auto reactWebView2 = view.as<winrt::ReactNativeWebView::ReactWebView2>();
+                std::string const fileScheme = "file://";
+                if (srcMap.find("uri") != srcMap.end()) {
+                    auto uriString = srcMap.at("uri").AsString();
+                    if (uriString.length() == 0) {
+                        continue;
+                    }
+
+                    bool isPackagerAsset = false;
+                    if (srcMap.find("__packager_asset") != srcMap.end()) {
+                        isPackagerAsset = srcMap.at("__packager_asset").AsBoolean();
+                    }
+                    if (isPackagerAsset && uriString.find(fileScheme) == 0) {
+                        auto bundleRootPath = winrt::to_string(ReactNativeHost().InstanceSettings().BundleRootPath());
+                        uriString.replace(0, std::size(fileScheme), bundleRootPath.empty() ? "ms-appx-web:///Bundle/" : bundleRootPath);
+                    }
+                    if (uriString.find("ms-appdata://") == 0 || uriString.find("ms-appx-web://") == 0) {
+                        reactWebView2.NavigateToHtml(to_hstring(uriString));
+                    } else {
+                        reactWebView2.NavigateWithWebResourceRequest(MakeJSValueTreeReader(JSValue(srcMap.Copy())));
+                    }
+                }
+                else if (srcMap.find("html") != srcMap.end()) {
+                    auto htmlString = srcMap.at("html").AsString();
+                    reactWebView2.NavigateToHtml(to_hstring(htmlString));
+                }
+            }
+            else if (propertyName == "messagingEnabled") {
+                auto messagingEnabled = propertyValue.To<bool>();
+                auto reactWebView2 = view.as<ReactNativeWebView::ReactWebView2>();
+                reactWebView2.MessagingEnabled(messagingEnabled);
+            }
+            else if (propertyName == "injectedJavaScript")
+            {
+                auto injectedJavascript = propertyValue.AsString();
+                auto reactWebView2 = view.as<ReactNativeWebView::ReactWebView2>();
+                reactWebView2.InjectedJavascript(to_hstring(injectedJavascript));
+            }
+            else if (propertyName == "linkHandlingEnabled") {
+                auto linkHandlingEnabled = propertyValue.To<bool>();
+                auto reactWebView2 = view.as<ReactNativeWebView::ReactWebView2>();
+                reactWebView2.LinkHandlingEnabled(linkHandlingEnabled);
+            }
+        }
+    }
+
+    // IViewManagerWithExportedEventTypeConstants
+    ConstantProviderDelegate ReactWebView2Manager::ExportedCustomBubblingEventTypeConstants() noexcept {
+        return nullptr;
+    }
+
+    ConstantProviderDelegate ReactWebView2Manager::ExportedCustomDirectEventTypeConstants() noexcept {
+        return [](winrt::IJSValueWriter const& constantWriter) {
+            WriteCustomDirectEventTypeConstant(constantWriter, "DOMContentLoaded");
+            WriteCustomDirectEventTypeConstant(constantWriter, "LoadingStart");
+            WriteCustomDirectEventTypeConstant(constantWriter, "LoadingFinish");
+            WriteCustomDirectEventTypeConstant(constantWriter, "LoadingError");
+            WriteCustomDirectEventTypeConstant(constantWriter, "Message");
+            WriteCustomDirectEventTypeConstant(constantWriter, "FrameNavigationStart");
+            WriteCustomDirectEventTypeConstant(constantWriter, "FrameNavigationFinish");
+            WriteCustomDirectEventTypeConstant(constantWriter, "OpenWindow");
+            WriteCustomDirectEventTypeConstant(constantWriter, "SourceChanged");
+        };
+    }
+
+    // IViewManagerWithCommands
+    IVectorView<hstring> ReactWebView2Manager::Commands() noexcept {
+        auto commands = winrt::single_threaded_vector<hstring>();
+        commands.Append(L"goForward");
+        commands.Append(L"goBack");
+        commands.Append(L"reload");
+        commands.Append(L"stopLoading");
+        commands.Append(L"injectJavaScript");
+        commands.Append(L"requestFocus");
+        commands.Append(L"clearCache");
+        commands.Append(L"postMessage");
+        commands.Append(L"loadUrl");
+        return commands.GetView();
+    }
+
+    void ReactWebView2Manager::DispatchCommand(
+        FrameworkElement const& view,
+        winrt::hstring const& commandId,
+        winrt::IJSValueReader const& commandArgsReader) noexcept {
+        auto control = view.as<winrt::ContentPresenter>();
+        auto content = control.Content();
+        auto webView = content.as<mux::WebView2>();
+        auto commandArgs = JSValue::ReadArrayFrom(commandArgsReader);
+
+        if (commandId == L"goForward") {
+            if (webView.CanGoForward()) {
+                webView.GoForward();
+            }
+        }
+        else if (commandId == L"goBack") {
+            if (webView.CanGoBack()) {
+                webView.GoBack();
+            }
+        }
+        else if (commandId == L"reload") {
+            webView.Reload();
+        }
+        else if (commandId == L"stopLoading") {
+            if (webView.CoreWebView2() != nullptr) {
+                webView.CoreWebView2().Stop();
+            }
+        }
+        else if (commandId == L"injectJavaScript") {
+            webView.ExecuteScriptAsync(winrt::to_hstring(commandArgs[0].AsString()));
+        }
+        else if (commandId == L"requestFocus") {
+            FocusManager::TryFocusAsync(webView, FocusState::Programmatic);
+        }
+        else if (commandId == L"clearCache") {
+            // There is no way to clear the cache in WebView2 because it is shared with Edge.
+            // The best we can do is clear the cookies, because we cannot access history or local storage.
+            auto cookieManager = webView.CoreWebView2().CookieManager();
+            cookieManager.DeleteAllCookies();
+        }
+        else if (commandId == L"loadUrl") {
+            auto uri = winrt::Uri(to_hstring(commandArgs[0].AsString()));
+            webView.Source(uri);
+        }
+        else if (commandId == L"postMessage") {
+            if (webView.CoreWebView2() != nullptr) {
+                auto message = commandArgs[0].AsString();
+                webView.CoreWebView2().PostWebMessageAsString(to_hstring(message));
+            }
+        }
+    }
+
+} // namespace winrt::ReactNativeWebView::implementation
+
+#endif // HAS_WEBVIEW2

package/windows/ReactNativeWebView/ReactWebView2Manager.h

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "ReactWebView2.h"
+
+#if HAS_WEBVIEW2
+#include "winrt/Microsoft.ReactNative.h"
+#include "NativeModules.h"
+
+namespace winrt::ReactNativeWebView::implementation {
+
+    class ReactWebView2Manager : public winrt::implements<
+        ReactWebView2Manager,
+        winrt::Microsoft::ReactNative::IViewManager,
+        winrt::Microsoft::ReactNative::IViewManagerWithReactContext,
+        winrt::Microsoft::ReactNative::IViewManagerWithNativeProperties,
+        winrt::Microsoft::ReactNative::IViewManagerWithExportedEventTypeConstants,
+        winrt::Microsoft::ReactNative::IViewManagerWithCommands> {
+    public:
+        ReactWebView2Manager();
+        // IViewManager
+        winrt::hstring Name() noexcept;
+        xaml::FrameworkElement CreateView() noexcept;
+
+        // IViewManagerWithReactContext
+        winrt::Microsoft::ReactNative::IReactContext ReactContext() noexcept;
+        void ReactContext(winrt::Microsoft::ReactNative::IReactContext reactContext) noexcept;
+
+        // IViewManagerWithNativeProperties
+        winrt::Windows::Foundation::Collections::
+            IMapView<winrt::hstring, winrt::Microsoft::ReactNative::ViewManagerPropertyType>
+            NativeProps() noexcept;
+
+        void UpdateProperties(
+            xaml::FrameworkElement const& view,
+            winrt::Microsoft::ReactNative::IJSValueReader const& propertyMapReader) noexcept;
+
+        // IViewManagerWithExportedEventTypeConstants
+        winrt::Microsoft::ReactNative::ConstantProviderDelegate ExportedCustomBubblingEventTypeConstants() noexcept;
+        winrt::Microsoft::ReactNative::ConstantProviderDelegate ExportedCustomDirectEventTypeConstants() noexcept;
+
+        // IViewManagerWithCommands
+        winrt::Windows::Foundation::Collections::IVectorView<winrt::hstring> Commands() noexcept;
+
+        void DispatchCommand(
+            xaml::FrameworkElement const& view,
+            winrt::hstring const& commandId,
+            winrt::Microsoft::ReactNative::IJSValueReader const& commandArgsReader) noexcept;
+
+    private:
+        winrt::Microsoft::ReactNative::IReactContext m_reactContext{ nullptr };
+
+    };
+} // namespace winrt::ReactNativeWebView::implementation
+#endif // HAS_WEBVIEW2

package/windows/ReactNativeWebView/ReactWebViewHelpers.cpp

@@ -0,0 +1,70 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once 
+
+#include "pch.h"
+#include "winrt/ReactNativeWebView.h"
+
+using namespace winrt::ReactNativeWebView;
+
+namespace winrt::ReactNativeWebView::implementation {
+    namespace ReactWebViewHelpers {
+        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 winrt::ReactNativeWebView::implementation

package/windows/ReactNativeWebView/ReactWebViewHelpers.h

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once 
+
+#include "winrt/ReactNativeWebView.h"
+
+using namespace winrt::ReactNativeWebView;
+
+namespace winrt::ReactNativeWebView::implementation {
+    namespace ReactWebViewHelpers {
+        std::string TrimString(const std::string& str);
+        std::vector<std::string> SplitString(const std::string& str, const std::string& delim);
+        std::map<std::string, std::string> ParseSetCookieHeader(const std::string& setCookieHeader);
+    }
+} // namespace winrt::ReactNativeWebView::implementation

package/windows/ReactNativeWebView/ReactWebViewManager.cpp

@@ -0,0 +1,224 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#ifndef USE_WINUI3
+
+#include "ReactWebViewManager.h"
+#include "NativeModules.h"
+#include "ReactWebView.h"
+#include "JSValueXaml.h"
+
+
+namespace winrt {
+    using namespace Microsoft::ReactNative;
+    using namespace Windows::Foundation;
+    using namespace Windows::Foundation::Collections;
+    using namespace Windows::UI;
+    using namespace Windows::UI::Xaml;
+    using namespace Windows::UI::Xaml::Controls;
+    using namespace Windows::Web::Http;
+    using namespace Windows::Web::Http::Headers;
+}
+
+namespace winrt::ReactNativeWebView::implementation {
+
+    ReactWebViewManager::ReactWebViewManager() {}
+
+    // IViewManager
+    winrt::hstring ReactWebViewManager::Name() noexcept {
+        return L"RCTWebView";
+    }
+
+    winrt::FrameworkElement ReactWebViewManager::CreateView() noexcept {
+      auto view = winrt::ReactNativeWebView::ReactWebView(m_reactContext);
+      return view;
+    }
+
+    // IViewManagerWithReactContext
+    winrt::IReactContext ReactWebViewManager::ReactContext() noexcept {
+        return m_reactContext;
+    }
+
+    void ReactWebViewManager::ReactContext(IReactContext reactContext) noexcept {
+        m_reactContext = reactContext;
+    }
+
+    // IViewManagerWithNativeProperties
+    IMapView<hstring, ViewManagerPropertyType> ReactWebViewManager::NativeProps() noexcept {
+        auto nativeProps = winrt::single_threaded_map<hstring, ViewManagerPropertyType>();
+        nativeProps.Insert(L"source", ViewManagerPropertyType::Map);
+        nativeProps.Insert(L"backgroundColor", ViewManagerPropertyType::Color);
+        nativeProps.Insert(L"messagingEnabled", ViewManagerPropertyType::Boolean);
+        return nativeProps.GetView();
+    }
+
+    void ReactWebViewManager::UpdateProperties(
+        FrameworkElement const& view,
+        IJSValueReader const& propertyMapReader) noexcept {
+        auto control = view.as<winrt::ContentPresenter>();
+        auto content = control.Content();
+        auto webView = content.as<winrt::WebView>();
+        const JSValueObject& propertyMap = JSValueObject::ReadFrom(propertyMapReader);
+
+        for (auto const& pair : propertyMap) {
+            auto const& propertyName = pair.first;
+            auto const& propertyValue = pair.second;
+            if (propertyValue.IsNull()) continue;
+
+            if (propertyName == "source") {
+                auto const& srcMap = propertyValue.AsObject();
+                if (srcMap.find("uri") != srcMap.end()) {
+                    auto uriString = srcMap.at("uri").AsString();
+                    if (uriString.length() == 0) {
+                        continue;
+                    }
+
+                    bool isPackagerAsset = false;
+                    if (srcMap.find("__packager_asset") != srcMap.end()) {
+                        isPackagerAsset = srcMap.at("__packager_asset").AsBoolean();
+                    }
+                    if (isPackagerAsset && uriString.find("file://") == 0) {
+                        auto bundleRootPath = winrt::to_string(ReactNativeHost().InstanceSettings().BundleRootPath());
+                        uriString.replace(0, 7, bundleRootPath.empty() ? "ms-appx-web:///Bundle/" : bundleRootPath);
+                    }
+
+                    if (uriString.find("ms-appdata://") == 0 || uriString.find("ms-appx-web://") == 0) {
+                        webView.Navigate(winrt::Uri(to_hstring(uriString)));
+                    }
+                    else {
+                        bool hasHeaders = srcMap.find("headers") != srcMap.end();
+                        auto httpRequest = winrt::HttpRequestMessage();
+                        httpRequest.RequestUri(winrt::Uri(to_hstring(uriString)));
+                        if (srcMap.find("method") != srcMap.end() && srcMap.at("method").AsString() == "POST")
+                        {
+                          httpRequest.Method(winrt::HttpMethod::Post());
+                          auto formBody = srcMap.at("body").AsString();
+                          bool isUrlEncodedForm = hasHeaders &&
+                            srcMap.at("headers").AsObject().find("content-type") !=
+                            srcMap.at("headers").AsObject().end() &&
+                            srcMap.at("headers").AsObject().at("content-type") == "application/x-www-form-urlencoded";
+                          if (isUrlEncodedForm)
+                          {
+                            auto formContent = winrt::single_threaded_observable_map<winrt::hstring, winrt::hstring>();
+                            size_t counter = 0u;
+                            auto current = formBody.find_first_of("&");
+                            while (counter <= formBody.find_last_of("&"))
+                            {
+                              auto keyValueSeparator = formBody.substr(counter, counter + current).find('=');
+                              if (keyValueSeparator <= current)
+                              {
+                                auto key = winrt::to_hstring(formBody.substr(counter, keyValueSeparator));
+                                auto value = winrt::to_hstring(formBody.substr(
+                                  keyValueSeparator + counter + 1, current - keyValueSeparator - 1));
+                                formContent.Insert(key, value);
+                              }
+                              counter += current + 1;
+                              current = formBody.substr(counter, formBody.size() - counter).find_first_of("&");
+                            }
+                            httpRequest.Content(winrt::HttpFormUrlEncodedContent(formContent));
+                            httpRequest.Headers().Accept().TryParseAdd(L"application/x-www-form-urlencoded");
+                          }
+                          else
+                          {
+                            httpRequest.Content(winrt::HttpStringContent(to_hstring(formBody)));
+                          }
+                        }
+                        if (hasHeaders) {
+                          for (auto const& header : srcMap.at("headers").AsObject()) {
+                            auto const& headerKey = header.first;
+                            auto const& headerValue = header.second;
+                            if (headerValue.IsNull()) continue;
+                            httpRequest.Headers().TryAppendWithoutValidation(winrt::to_hstring(headerKey), winrt::to_hstring(headerValue.AsString()));
+                          }
+                        }
+                        webView.NavigateWithHttpRequestMessage(httpRequest);
+                    }
+                }
+                else if (srcMap.find("html") != srcMap.end()) {
+                    auto htmlString = srcMap.at("html").AsString();
+                    webView.NavigateToString(to_hstring(htmlString));
+                }
+            }
+            else if (propertyName == "backgroundColor") {
+                auto color = propertyValue.To<winrt::Color>();
+                webView.DefaultBackgroundColor(color.A==0 ? winrt::Colors::Transparent() : color);
+            }
+            else if (propertyName == "messagingEnabled") {
+              auto messagingEnabled = propertyValue.To<bool>();
+              auto reactWebView = view.as<ReactNativeWebView::ReactWebView>();
+              reactWebView.MessagingEnabled(messagingEnabled);
+            }
+        }
+    }
+
+    // IViewManagerWithExportedEventTypeConstants
+    ConstantProviderDelegate ReactWebViewManager::ExportedCustomBubblingEventTypeConstants() noexcept {
+        return nullptr;
+    }
+
+    ConstantProviderDelegate ReactWebViewManager::ExportedCustomDirectEventTypeConstants() noexcept {
+        return [](winrt::IJSValueWriter const& constantWriter) {
+            WriteCustomDirectEventTypeConstant(constantWriter, "LoadingStart");
+            WriteCustomDirectEventTypeConstant(constantWriter, "LoadingFinish");
+            WriteCustomDirectEventTypeConstant(constantWriter, "LoadingError");
+            WriteCustomDirectEventTypeConstant(constantWriter, "Message");
+            WriteCustomDirectEventTypeConstant(constantWriter, "DOMContentLoaded");
+            WriteCustomDirectEventTypeConstant(constantWriter, "Message");
+        };
+    }
+
+    // IViewManagerWithCommands
+    IVectorView<hstring> ReactWebViewManager::Commands() noexcept {
+        auto commands = winrt::single_threaded_vector<hstring>();
+        commands.Append(L"goForward");
+        commands.Append(L"goBack");
+        commands.Append(L"reload");
+        commands.Append(L"stopLoading");
+        commands.Append(L"injectJavaScript");
+        commands.Append(L"postMessage");
+        commands.Append(L"loadUrl");
+        return commands.GetView();
+    }
+
+    void ReactWebViewManager::DispatchCommand(
+        FrameworkElement const& view,
+        winrt::hstring const& commandId,
+        winrt::IJSValueReader const& commandArgsReader) noexcept {
+        auto control = view.as<winrt::ContentPresenter>();
+        auto content = control.Content();
+        auto webView = content.as<winrt::WebView>();
+        auto commandArgs = JSValue::ReadArrayFrom(commandArgsReader);
+
+        if (commandId == L"goForward") {
+            if (webView.CanGoForward()) {
+                webView.GoForward();
+            }
+        }
+        else if (commandId == L"goBack") {
+            if (webView.CanGoBack()) {
+                webView.GoBack();
+            }
+        }
+        else if (commandId == L"reload") {
+            webView.Refresh();
+        }
+        else if (commandId == L"stopLoading") {
+            webView.Stop();
+        }
+        else if (commandId == L"injectJavaScript") {
+            webView.InvokeScriptAsync(L"eval", { winrt::to_hstring(commandArgs[0].AsString()) });
+        }
+        else if (commandId == L"postMessage") {
+            auto reactWebView = view.as<ReactNativeWebView::ReactWebView>();
+            reactWebView.PostMessage(to_hstring(commandArgs[0].AsString()));
+        }
+        else if (commandId == L"loadUrl") {
+            webView.Navigate(winrt::Uri(to_hstring(commandArgs[0].AsString())));
+        }
+    }
+
+} // namespace winrt::ReactWebView::implementation
+
+#endif // USE_WINUI3

package/windows/ReactNativeWebView/ReactWebViewManager.h

@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#ifndef USE_WINUI3
+
+#include "winrt/Microsoft.ReactNative.h"
+#include "NativeModules.h"
+#include "ReactWebView.h"
+
+namespace winrt::ReactNativeWebView::implementation {
+
+    class ReactWebViewManager : public winrt::implements<
+        ReactWebViewManager,
+        winrt::Microsoft::ReactNative::IViewManager,
+        winrt::Microsoft::ReactNative::IViewManagerWithReactContext,
+        winrt::Microsoft::ReactNative::IViewManagerWithNativeProperties,
+        winrt::Microsoft::ReactNative::IViewManagerWithExportedEventTypeConstants,
+        winrt::Microsoft::ReactNative::IViewManagerWithCommands> {
+    public:
+        ReactWebViewManager();
+        // IViewManager
+        winrt::hstring Name() noexcept;
+        winrt::Windows::UI::Xaml::FrameworkElement CreateView() noexcept;
+
+        // IViewManagerWithReactContext
+        winrt::Microsoft::ReactNative::IReactContext ReactContext() noexcept;
+        void ReactContext(winrt::Microsoft::ReactNative::IReactContext reactContext) noexcept;
+
+        // IViewManagerWithNativeProperties
+        winrt::Windows::Foundation::Collections::
+            IMapView<winrt::hstring, winrt::Microsoft::ReactNative::ViewManagerPropertyType>
+            NativeProps() noexcept;
+
+        void UpdateProperties(
+            winrt::Windows::UI::Xaml::FrameworkElement const& view,
+            winrt::Microsoft::ReactNative::IJSValueReader const& propertyMapReader) noexcept;
+
+        // IViewManagerWithExportedEventTypeConstants
+        winrt::Microsoft::ReactNative::ConstantProviderDelegate ExportedCustomBubblingEventTypeConstants() noexcept;
+        winrt::Microsoft::ReactNative::ConstantProviderDelegate ExportedCustomDirectEventTypeConstants() noexcept;
+
+        // IViewManagerWithCommands
+        winrt::Windows::Foundation::Collections::IVectorView<winrt::hstring> Commands() noexcept;
+
+        void DispatchCommand(
+            winrt::Windows::UI::Xaml::FrameworkElement const& view,
+            winrt::hstring const& commandId,
+            winrt::Microsoft::ReactNative::IJSValueReader const& commandArgsReader) noexcept;
+
+    private:
+        winrt::Microsoft::ReactNative::IReactContext m_reactContext{ nullptr };
+
+    };
+} // namespace winrt::ReactWebView::implementation
+
+#endif  // USE_WINUI3

package/windows/ReactNativeWebView/WebBridge.cpp

@@ -0,0 +1,19 @@
+#include "pch.h"
+#include "WebBridge.h"
+#include "WebBridge.g.cpp"
+
+namespace winrt::ReactNativeWebView::implementation
+{
+    void WebBridge::PostMessage(hstring const& message)
+    {
+        m_messageEvent(*this, message);
+    }
+    winrt::event_token WebBridge::MessagePostEvent(Windows::Foundation::EventHandler<hstring> const& handler)
+    {
+        return m_messageEvent.add(handler);
+    }
+    void WebBridge::MessagePostEvent(winrt::event_token const& token) noexcept
+    {
+        m_messageEvent.remove(token);
+    }
+}

package/windows/ReactNativeWebView/WebBridge.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "WebBridge.g.h"
+
+
+namespace winrt::ReactNativeWebView::implementation
+{
+    struct WebBridge : WebBridgeT<WebBridge>
+    {
+        WebBridge() = default;
+
+        void PostMessage(hstring const& message);
+        winrt::event_token MessagePostEvent(Windows::Foundation::EventHandler<hstring> const& handler);
+        void MessagePostEvent(winrt::event_token const& token) noexcept;
+
+    private:
+      winrt::event<Windows::Foundation::EventHandler<winrt::hstring>> m_messageEvent;
+    };
+}
+namespace winrt::ReactNativeWebView::factory_implementation
+{
+    struct WebBridge : WebBridgeT<WebBridge, implementation::WebBridge>
+    {
+    };
+}