@javascriptcommon/react-native-webview 13.12.16

package/src/__tests__/WebViewShared-test.js

@@ -0,0 +1,323 @@
+import { Linking } from 'react-native';
+
+import {
+  defaultOriginWhitelist,
+  createOnShouldStartLoadWithRequest,
+} from '../WebViewShared';
+
+Linking.openURL.mockResolvedValue(undefined);
+Linking.canOpenURL.mockResolvedValue(true);
+
+// The tests that call createOnShouldStartLoadWithRequest will cause a promise
+// to get kicked off (by calling the mocked `Linking.canOpenURL`) that the tests
+// _need_ to get run to completion _before_ doing any `expect`ing. The reason
+// is: once that promise is resolved another function should get run which will
+// call `Linking.openURL`, and we want to test that.
+//
+// Normally we would probably do something like `await
+// createShouldStartLoadWithRequest(...)` in the tests, but that doesn't work
+// here because the promise that gets kicked off is not returned (because
+// non-test code doesn't need to know about it).
+//
+// The tests thus need a way to "flush any pending promises" (to make sure
+// pending promises run to completion) before doing any `expect`ing. `jest`
+// doesn't provide a way to do this out of the box, but we can use this function
+// to do it.
+//
+// See this issue for more discussion: https://github.com/facebook/jest/issues/2157
+function flushPromises() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+
+describe('WebViewShared', () => {
+  test('exports defaultOriginWhitelist', () => {
+    expect(defaultOriginWhitelist).toMatchSnapshot();
+  });
+
+  describe('createOnShouldStartLoadWithRequest', () => {
+    const alwaysTrueOnShouldStartLoadWithRequest = (nativeEvent) => {
+      return true;
+    };
+
+    const alwaysFalseOnShouldStartLoadWithRequest = (nativeEvent) => {
+      return false;
+    };
+
+    const loadRequest = jest.fn();
+
+    test('loadRequest is called without onShouldStartLoadWithRequest override', async () => {
+      const onShouldStartLoadWithRequest = createOnShouldStartLoadWithRequest(
+        loadRequest,
+        defaultOriginWhitelist
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: { url: 'https://www.example.com/', lockIdentifier: 1 },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenCalledTimes(0);
+      expect(loadRequest).toHaveBeenCalledWith(
+        true,
+        'https://www.example.com/',
+        1
+      );
+    });
+
+    test('Linking.openURL is called without onShouldStartLoadWithRequest override', async () => {
+      const onShouldStartLoadWithRequest = createOnShouldStartLoadWithRequest(
+        loadRequest,
+        defaultOriginWhitelist
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: { url: 'invalid://example.com/', lockIdentifier: 2 },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenCalledWith('invalid://example.com/');
+      expect(loadRequest).toHaveBeenCalledWith(
+        false,
+        'invalid://example.com/',
+        2
+      );
+    });
+
+    test('loadRequest with true onShouldStartLoadWithRequest override is called', async () => {
+      const onShouldStartLoadWithRequest = createOnShouldStartLoadWithRequest(
+        loadRequest,
+        defaultOriginWhitelist,
+        alwaysTrueOnShouldStartLoadWithRequest
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: { url: 'https://www.example.com/', lockIdentifier: 1 },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenCalledTimes(0);
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        true,
+        'https://www.example.com/',
+        1
+      );
+    });
+
+    test('Linking.openURL with true onShouldStartLoadWithRequest override is called for links not passing the whitelist', async () => {
+      const onShouldStartLoadWithRequest = createOnShouldStartLoadWithRequest(
+        loadRequest,
+        defaultOriginWhitelist,
+        alwaysTrueOnShouldStartLoadWithRequest
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: { url: 'invalid://example.com/', lockIdentifier: 1 },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenLastCalledWith(
+        'invalid://example.com/'
+      );
+      // We don't expect the URL to have been loaded in the WebView because it
+      // is not in the origin whitelist
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        false,
+        'invalid://example.com/',
+        1
+      );
+    });
+
+    test('loadRequest with false onShouldStartLoadWithRequest override is called', async () => {
+      const onShouldStartLoadWithRequest = createOnShouldStartLoadWithRequest(
+        loadRequest,
+        defaultOriginWhitelist,
+        alwaysFalseOnShouldStartLoadWithRequest
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: { url: 'https://www.example.com/', lockIdentifier: 1 },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenCalledTimes(0);
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        false,
+        'https://www.example.com/',
+        1
+      );
+    });
+
+    test('loadRequest with limited whitelist', async () => {
+      const onShouldStartLoadWithRequest = createOnShouldStartLoadWithRequest(
+        loadRequest,
+        ['https://*']
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: { url: 'https://www.example.com/', lockIdentifier: 1 },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenCalledTimes(0);
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        true,
+        'https://www.example.com/',
+        1
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: { url: 'http://insecure.com/', lockIdentifier: 2 },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenLastCalledWith('http://insecure.com/');
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        false,
+        'http://insecure.com/',
+        2
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: { url: 'git+https://insecure.com/', lockIdentifier: 3 },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenLastCalledWith(
+        'git+https://insecure.com/'
+      );
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        false,
+        'git+https://insecure.com/',
+        3
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: { url: 'fakehttps://insecure.com/', lockIdentifier: 4 },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenLastCalledWith(
+        'fakehttps://insecure.com/'
+      );
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        false,
+        'fakehttps://insecure.com/',
+        4
+      );
+    });
+
+    test('loadRequest allows for valid URIs', async () => {
+      const onShouldStartLoadWithRequest = createOnShouldStartLoadWithRequest(
+        loadRequest,
+        [
+          'plus+https://*',
+          'DOT.https://*',
+          'dash-https://*',
+          '0invalid://*',
+          '+invalid://*',
+        ]
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: {
+          url: 'plus+https://www.example.com/',
+          lockIdentifier: 1,
+        },
+      });
+
+      await flushPromises();
+      expect(Linking.openURL).toHaveBeenCalledTimes(0);
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        true,
+        'plus+https://www.example.com/',
+        1
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: { url: 'DOT.https://www.example.com/', lockIdentifier: 2 },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenCalledTimes(0);
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        true,
+        'DOT.https://www.example.com/',
+        2
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: {
+          url: 'dash-https://www.example.com/',
+          lockIdentifier: 3,
+        },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenCalledTimes(0);
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        true,
+        'dash-https://www.example.com/',
+        3
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: { url: '0invalid://www.example.com/', lockIdentifier: 4 },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenLastCalledWith(
+        '0invalid://www.example.com/'
+      );
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        false,
+        '0invalid://www.example.com/',
+        4
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: { url: '+invalid://www.example.com/', lockIdentifier: 5 },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenLastCalledWith(
+        '+invalid://www.example.com/'
+      );
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        false,
+        '+invalid://www.example.com/',
+        5
+      );
+
+      onShouldStartLoadWithRequest({
+        nativeEvent: {
+          url: 'FAKE+plus+https://www.example.com/',
+          lockIdentifier: 6,
+        },
+      });
+
+      await flushPromises();
+
+      expect(Linking.openURL).toHaveBeenLastCalledWith(
+        'FAKE+plus+https://www.example.com/'
+      );
+      expect(loadRequest).toHaveBeenLastCalledWith(
+        false,
+        'FAKE+plus+https://www.example.com/',
+        6
+      );
+    });
+  });
+});

package/src/__tests__/__snapshots__/WebViewShared-test.js.snap

@@ -0,0 +1,8 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`WebViewShared exports defaultOriginWhitelist 1`] = `
+[
+  "http://*",
+  "https://*",
+]
+`;

package/src/index.ts

@@ -0,0 +1,4 @@
+import WebView from './WebView';
+
+export { WebView };
+export default WebView;

package/windows/ExperimentalFeatures.props

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <!-- Flags can be added here to effect the compilation of Microsoft.ReactNative -->
+  <PropertyGroup Label="Microsoft.ReactNative Build Flags">
+    <UseWinUI3>false</UseWinUI3>
+    <UseHermes>false</UseHermes>
+    <WinUI2xVersion>2.8.0-prerelease.210927001</WinUI2xVersion>
+  </PropertyGroup>
+
+</Project>

package/windows/ReactNativeWebView/PropertySheet.props

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <!--
+    To customize common C++/WinRT project properties: 
+    * right-click the project node
+    * expand the Common Properties item
+    * select the C++/WinRT property page
+
+    For more advanced scenarios, and complete documentation, please see:
+    https://github.com/Microsoft/cppwinrt/tree/master/nuget 
+    -->
+  <PropertyGroup />
+  <ItemDefinitionGroup />
+</Project>

package/windows/ReactNativeWebView/ReactNativeWebView.def

@@ -0,0 +1,3 @@
+EXPORTS
+DllCanUnloadNow = WINRT_CanUnloadNow                    PRIVATE
+DllGetActivationFactory = WINRT_GetActivationFactory    PRIVATE

package/windows/ReactNativeWebView/ReactNativeWebView.filters

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Resources">
+      <UniqueIdentifier>accd3aa8-1ba0-4223-9bbe-0c431709210b</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tga;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+    <Filter Include="Generated Files">
+      <UniqueIdentifier>{926ab91d-31b4-48c3-b9a4-e681349f27f0}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="pch.cpp" />
+    <ClCompile Include="$(GeneratedFilesDir)module.g.cpp" />
+    <ClCompile Include="ReactPackageProvider.cpp" />
+    <ClCompile Include="WebViewManager.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="ReactPackageProvider.h" />
+    <ClInclude Include="WebViewManager.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="ReactNativeWebView.def" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="PropertySheet.props" />
+  </ItemGroup>
+  <ItemGroup>
+    <Midl Include="ReactPackageProvider.idl" />
+  </ItemGroup>
+</Project>

package/windows/ReactNativeWebView/ReactNativeWebView.vcxproj

@@ -0,0 +1,189 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(SolutionDir)\ExperimentalFeatures.props" Condition="Exists('$(SolutionDir)\ExperimentalFeatures.props')" />
+  <Import Project="$(SolutionDir)packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.props" Condition="Exists('$(SolutionDir)packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.props')" />
+  <PropertyGroup Label="Globals">
+    <CppWinRTOptimized>true</CppWinRTOptimized>
+    <CppWinRTRootNamespaceAutoMerge>true</CppWinRTRootNamespaceAutoMerge>
+    <MinimalCoreWin>true</MinimalCoreWin>
+    <ProjectGuid>{00AA3765-C6A0-4713-B3F9-BFE47B9C83F5}</ProjectGuid>
+    <ProjectName>ReactNativeWebView</ProjectName>
+    <RootNamespace>ReactNativeWebView</RootNamespace>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
+    <AppContainerApplication>true</AppContainerApplication>
+    <ApplicationType>Windows Store</ApplicationType>
+    <ApplicationTypeRevision>10.0</ApplicationTypeRevision>
+    <WindowsTargetPlatformVersion Condition=" '$(WindowsTargetPlatformVersion)' == '' ">10.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' == '15.0'">v141</PlatformToolset>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' == '16.0'">v142</PlatformToolset>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' == '17.0'">v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <PropertyGroup>
+    <ReactNativeWindowsDir Condition="'$(ReactNativeWindowsDir)' == ''">$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), 'node_modules\react-native-windows\package.json'))\node_modules\react-native-windows\</ReactNativeWindowsDir>
+  </PropertyGroup>
+  <ImportGroup Label="Shared">
+    <Import Project="$(ReactNativeWindowsDir)\Microsoft.ReactNative.Cxx\Microsoft.ReactNative.Cxx.vcxitems" Label="Shared" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="PropertySheet.props" />
+  </ImportGroup>
+  <ImportGroup Label="ReactNativeWindowsPropertySheets">
+    <Import Project="$(ReactNativeWindowsDir)\PropertySheets\external\Microsoft.ReactNative.Uwp.CppLib.props" Condition="Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.Uwp.CppLib.props')" />
+    <Import Project="$(SolutionDir)\packages\$(WinUIPackageProps)" Condition="'$(WinUIPackageProps)'!='' And Exists('$(SolutionDir)\packages\$(WinUIPackageProps)')" />
+  </ImportGroup>
+  <PropertyGroup>
+    <WinUI2_HasWebView2 Condition="$([MSBuild]::VersionGreaterThanOrEquals('$(WinUIPackageVersion)','2.8.0-prerelease.210927001'))">true</WinUI2_HasWebView2>
+  </PropertyGroup>
+  <PropertyGroup />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>$(IntDir)pch.pch</PrecompiledHeaderOutputFile>
+      <WarningLevel>Level4</WarningLevel>
+      <AdditionalOptions>%(AdditionalOptions) /bigobj</AdditionalOptions>
+      <!--Temporarily disable cppwinrt heap enforcement to work around xaml compiler generated std::shared_ptr use -->
+      <AdditionalOptions Condition="'$(CppWinRTHeapEnforcement)'==''">/DWINRT_NO_MAKE_DETECTION %(AdditionalOptions)</AdditionalOptions>
+      <DisableSpecificWarnings>28204</DisableSpecificWarnings>
+      <PreprocessorDefinitions>_WINRT_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateWindowsMetadata>true</GenerateWindowsMetadata>
+      <ModuleDefinitionFile>ReactNativeWebView.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(WinUI2_HasWebView2)'=='true'">
+    <ClCompile>
+      <PreprocessorDefinitions>WINUI2_HAS_WEBVIEW2;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Midl>
+      <PreprocessorDefinitions>WINUI2_HAS_WEBVIEW2;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </Midl>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="ReactWebView.h" />
+    <ClInclude Include="ReactWebView2.h" />
+    <ClInclude Include="ReactWebView2Manager.h" />
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="ReactPackageProvider.h">
+      <DependentUpon>ReactPackageProvider.idl</DependentUpon>
+    </ClInclude>
+    <ClInclude Include="ReactWebViewHelpers.h" />
+    <ClInclude Include="ReactWebViewManager.h" />
+    <ClInclude Include="WebBridge.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="ReactWebView.cpp" />
+    <ClCompile Include="ReactWebView2.cpp" />
+    <ClCompile Include="ReactWebView2Manager.cpp" />
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader>Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="ReactPackageProvider.cpp">
+      <DependentUpon>ReactPackageProvider.idl</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="$(GeneratedFilesDir)module.g.cpp" />
+    <ClCompile Include="ReactWebViewHelpers.cpp" />
+    <ClCompile Include="ReactWebViewManager.cpp" />
+    <ClCompile Include="WebBridge.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <Midl Include="ReactWebView.idl" />
+    <Midl Include="ReactPackageProvider.idl" />
+    <Midl Include="WebBridge.idl" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+    <None Include="ReactNativeWebView.def" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="PropertySheet.props" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="$(ReactNativeWindowsDir)\Microsoft.ReactNative\Microsoft.ReactNative.vcxproj">
+      <Project>{f7d32bd0-2749-483e-9a0d-1635ef7e3136}</Project>
+      <Private>false</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ReactNativeWindowsTargets">
+    <Import Project="$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.Uwp.CppLib.targets" Condition="Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.Uwp.CppLib.targets')" />
+  </ImportGroup>
+  <Target Name="EnsureReactNativeWindowsTargets" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references targets in your node_modules\react-native-windows folder that are missing. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.Uwp.CppLib.props')" Text="$([System.String]::Format('$(ErrorText)', '$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.Uwp.CppLib.props'))" />
+    <Error Condition="!Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.Uwp.CppLib.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.Uwp.CppLib.targets'))" />
+  </Target>
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(SolutionDir)packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('$(SolutionDir)packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.targets')" />
+    <Import Project="$(SolutionDir)packages\$(WinUIPackageName).$(WinUIPackageVersion)\build\native\$(WinUIPackageName).targets" Condition="Exists('$(SolutionDir)packages\$(WinUIPackageName).$(WinUIPackageVersion)\build\native\$(WinUIPackageName).targets')" />
+    <Import Project="$(SolutionDir)\packages\Microsoft.ReactNative.$(ReactNativeWindowsVersion)\build\native\Microsoft.ReactNative.targets" Condition="'$(UseExperimentalNuget)'=='true' And Exists('$(SolutionDir)\packages\Microsoft.ReactNative.Cxx.$(ReactNativeWindowsVersion)\build\native\Microsoft.ReactNative.Cxx.targets')" />
+    <Import Project="$(SolutionDir)\packages\Microsoft.ReactNative.Cxx.$(ReactNativeWindowsVersion)\build\native\Microsoft.ReactNative.Cxx.targets" Condition="'$(UseExperimentalNuget)'=='true' And Exists('$(SolutionDir)\packages\Microsoft.ReactNative.Cxx.$(ReactNativeWindowsVersion)\build\native\Microsoft.ReactNative.Cxx.targets')" />
+  </ImportGroup>
+  <Target Name="Deploy" />
+</Project>

package/windows/ReactNativeWebView/ReactPackageProvider.cpp

@@ -0,0 +1,26 @@
+#include "pch.h"
+#include "ReactPackageProvider.h"
+#if __has_include("ReactPackageProvider.g.cpp")
+#include "ReactPackageProvider.g.cpp"
+#endif
+
+#include "ReactWebView2Manager.h"
+#ifndef USE_WINUI3
+#include "ReactWebViewManager.h"
+#endif
+
+using namespace winrt::Microsoft::ReactNative;
+
+namespace winrt::ReactNativeWebView::implementation {
+
+void ReactPackageProvider::CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept {
+#ifndef USE_WINUI3
+  packageBuilder.AddViewManager(L"ReactWebViewManager", []() { return winrt::make<ReactWebViewManager>(); });
+#endif
+
+#if HAS_WEBVIEW2
+  packageBuilder.AddViewManager(L"ReactWebView2Manager", []() { return winrt::make<ReactWebView2Manager>(); });
+#endif
+}
+
+} // namespace winrt::ReactNativeWebView::implementation

package/windows/ReactNativeWebView/ReactPackageProvider.h

@@ -0,0 +1,20 @@
+#pragma once
+#include "ReactPackageProvider.g.h"
+
+using namespace winrt::Microsoft::ReactNative;
+
+namespace winrt::ReactNativeWebView::implementation {
+
+struct ReactPackageProvider : ReactPackageProviderT<ReactPackageProvider> {
+  ReactPackageProvider() = default;
+
+  void CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept;
+};
+
+} // namespace winrt::ReactNativeWebView::implementation
+
+namespace winrt::ReactNativeWebView::factory_implementation {
+
+struct ReactPackageProvider : ReactPackageProviderT<ReactPackageProvider, implementation::ReactPackageProvider> {};
+
+} // namespace winrt::ReactNativeWebView::factory_implementation

package/windows/ReactNativeWebView/ReactPackageProvider.idl

@@ -0,0 +1,7 @@
+namespace ReactNativeWebView {
+[webhosthidden]
+[default_interface] 
+runtimeclass ReactPackageProvider : Microsoft.ReactNative.IReactPackageProvider {
+  ReactPackageProvider();
+};
+} // namespace ReactNativeWebView