react-native-windows 0.66.3 → 0.67.0-preview.3

package/Microsoft.ReactNative/Modules/AlertModule.h

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 #pragma once
 
+#include "../../codegen/NativeDialogManagerWindowsSpec.g.h"
 #include <NativeModules.h>
 #include <winrt/Windows.ApplicationModel.h>
 #include <winrt/Windows.Foundation.h>
@@ -10,41 +11,33 @@
 
 namespace Microsoft::ReactNative {
 
-REACT_STRUCT(ShowAlertArgs)
-struct ShowAlertArgs {
-  REACT_FIELD(title)
-  std::string title;
-
-  REACT_FIELD(message)
-  std::string message;
-
-  REACT_FIELD(buttonPositive)
-  std::string buttonPositive;
-
-  REACT_FIELD(buttonNegative)
-  std::string buttonNegative;
-
-  REACT_FIELD(buttonNeutral)
-  std::string buttonNeutral;
-
-  REACT_FIELD(defaultButton)
-  int defaultButton;
-};
-
 REACT_MODULE(Alert)
 struct Alert : public std::enable_shared_from_this<Alert> {
+  using DialogOptions = ReactNativeSpecs::DialogManagerWindowsSpec_DialogOptions;
+  using Constants = ReactNativeSpecs::DialogManagerWindowsSpec_Constants;
+
   REACT_INIT(Initialize)
   void Initialize(React::ReactContext const &reactContext) noexcept;
 
   REACT_METHOD(showAlert)
-  void showAlert(ShowAlertArgs const &args, std::function<void(std::string)> result) noexcept;
+  void showAlert(
+      DialogOptions &&args,
+      std::function<void(std::string)> error,
+      std::function<void(std::string, int)> result) noexcept;
+
+  REACT_GET_CONSTANTS(GetConstants)
+  Constants GetConstants() noexcept;
 
  private:
   React::ReactContext m_context;
+  Constants m_constants;
 
   struct AlertRequest {
-    ShowAlertArgs args;
-    std::function<void(std::string)> result;
+    DialogOptions args;
+    std::function<void(std::string, int)> result;
+
+    AlertRequest(DialogOptions &&rargs, std::function<void(std::string, int)> rresult) noexcept
+        : args(std::move(rargs)), result(rresult) {}
   };
 
   std::queue<AlertRequest> pendingAlerts{};

package/Microsoft.ReactNative/Modules/Animated/InterpolationAnimatedNode.cpp

@@ -138,9 +138,10 @@ winrt::hstring InterpolationAnimatedNode::GetLeftExpression(
     const winrt::hstring &value,
     const winrt::hstring &leftInterpolateExpression) {
   const auto firstInput = s_inputName.data() + std::to_wstring(0);
+  const auto firstOutput = s_outputName.data() + std::to_wstring(0);
   switch (ExtrapolationTypeFromString(m_extrapolateLeft)) {
     case ExtrapolationType::Clamp:
-      return value + L" < " + firstInput + L" ? " + firstInput + L" : ";
+      return value + L" < " + firstInput + L" ? " + firstOutput + L" : ";
     case ExtrapolationType::Identity:
       return value + L" < " + firstInput + L" ? " + value + L" : ";
     case ExtrapolationType::Extend:
@@ -154,9 +155,10 @@ winrt::hstring InterpolationAnimatedNode::GetRightExpression(
     const winrt::hstring &value,
     const winrt::hstring &rightInterpolateExpression) {
   const auto lastInput = s_inputName.data() + std::to_wstring(m_inputRanges.size() - 1);
+  const auto lastOutput = s_outputName.data() + std::to_wstring(m_outputRanges.size() - 1);
   switch (ExtrapolationTypeFromString(m_extrapolateRight)) {
     case ExtrapolationType::Clamp:
-      return value + L" > " + lastInput + L" ? " + lastInput + L" : ";
+      return value + L" > " + lastInput + L" ? " + lastOutput + L" : ";
     case ExtrapolationType::Identity:
       return value + L" > " + lastInput + L" ? " + value + L" : ";
     case ExtrapolationType::Extend:

package/Microsoft.ReactNative/Modules/Animated/PropsAnimatedNode.cpp

@@ -121,7 +121,6 @@ void PropsAnimatedNode::StartAnimations() {
     if (const auto uiElement = GetUIElement()) {
       // Work around for https://github.com/microsoft/microsoft-ui-xaml/issues/2511
       EnsureUIElementDirtyForRender(uiElement);
-      uiElement.RotationAxis(m_rotationAxis);
       for (const auto &anim : m_expressionAnimations) {
         if (anim.second.Target() == L"Translation.X") {
           m_subchannelPropertySet.StartAnimation(L"TranslationX", anim.second);
@@ -135,6 +134,9 @@ void PropsAnimatedNode::StartAnimations() {
         } else if (anim.second.Target() == L"Scale.Y") {
           m_subchannelPropertySet.StartAnimation(L"ScaleY", anim.second);
           uiElement.StartAnimation(m_scaleCombined);
+        } else if (anim.second.Target() == L"Rotation") {
+          uiElement.RotationAxis(m_rotationAxis);
+          uiElement.StartAnimation(anim.second);
         } else {
           uiElement.StartAnimation(anim.second);
         }

package/Microsoft.ReactNative/Modules/AppStateModule.cpp

@@ -47,13 +47,11 @@ void AppState::Initialize(winrt::Microsoft::ReactNative::ReactContext const &rea
 }
 
 void AppState::GetCurrentAppState(
-    std::function<void(React::JSValue const &)> const &success,
+    std::function<void(AppStateChangeArgs const &)> const &success,
     std::function<void(React::JSValue const &)> const &error) noexcept {
-  auto writer = React::MakeJSValueTreeWriter();
-  writer.WriteObjectBegin();
-  React::WriteProperty(writer, "app_state", m_active ? "active" : "background");
-  writer.WriteObjectEnd();
-  success(React::TakeJSValue(writer));
+  AppStateChangeArgs args;
+  args.app_state = m_active ? "active" : "background";
+  success(args);
 }
 
 void AppState::AddListener(std::string && /*eventName*/) noexcept {
@@ -64,6 +62,10 @@ void AppState::RemoveListeners(double /*count*/) noexcept {
   // noop
 }
 
+ReactNativeSpecs::AppStateSpec_Constants AppState::GetConstants() noexcept {
+  return {m_active ? "active" : "background"};
+}
+
 void AppState::SetActive(bool active) noexcept {
   m_active = active;
   m_context.JSDispatcher().Post([this]() { AppStateDidChange({m_active ? "active" : "background"}); });

package/Microsoft.ReactNative/Modules/AppStateModule.h

@@ -2,26 +2,23 @@
 // Licensed under the MIT License.
 #pragma once
 
+#include "../../codegen/NativeAppStateSpec.g.h"
 #include <NativeModules.h>
 #include <winrt/Windows.ApplicationModel.h>
 #include <winrt/Windows.Foundation.h>
 
 namespace Microsoft::ReactNative {
 
-REACT_STRUCT(AppStateChangeArgs)
-struct AppStateChangeArgs {
-  REACT_FIELD(app_state)
-  std::string app_state;
-};
-
 REACT_MODULE(AppState)
 struct AppState : public std::enable_shared_from_this<AppState> {
+  using AppStateChangeArgs = ReactNativeSpecs::AppStateSpec_getCurrentAppState_success_appState;
+
   REACT_INIT(Initialize)
   void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 
   REACT_METHOD(GetCurrentAppState, L"getCurrentAppState")
   void GetCurrentAppState(
-      std::function<void(React::JSValue const &)> const &success,
+      std::function<void(AppStateChangeArgs const &)> const &success,
       std::function<void(React::JSValue const &)> const &error) noexcept;
 
   REACT_METHOD(AddListener, L"addListener")
@@ -30,8 +27,8 @@ struct AppState : public std::enable_shared_from_this<AppState> {
   REACT_METHOD(RemoveListeners, L"removeListeners")
   void RemoveListeners(double count) noexcept;
 
-  REACT_CONSTANT(initialAppState)
-  const std::string initialAppState{"active"};
+  REACT_GET_CONSTANTS(GetConstants)
+  ReactNativeSpecs::AppStateSpec_Constants GetConstants() noexcept;
 
   REACT_EVENT(AppStateDidChange, L"appStateDidChange")
   std::function<void(AppStateChangeArgs const &)> AppStateDidChange;

package/Microsoft.ReactNative/Modules/DeviceInfoModule.cpp

@@ -89,33 +89,43 @@ void DeviceInfoHolder::InitDeviceInfoHolder(const Mso::React::IReactContext &con
 
 void DeviceInfoHolder::notifyChanged() noexcept {
   if (m_notifyCallback) {
-    m_notifyCallback(getDimensions());
+    auto writer = MakeJSValueTreeWriter();
+    WriteValue(writer, getDimensions());
+    m_notifyCallback(TakeJSValue(writer).MoveObject());
   }
 }
 
-React::JSValueObject DeviceInfoHolder::GetDimensions(const React::ReactPropertyBag &propertyBag) noexcept {
+ReactNativeSpecs::DeviceInfoSpec_DimensionsPayload DeviceInfoHolder::GetDimensions(
+    const React::ReactPropertyBag &propertyBag) noexcept {
   auto holder = propertyBag.Get(DeviceInfoHolderPropertyId());
-
   return (*holder)->getDimensions();
 }
 
-React::JSValueObject DeviceInfoHolder::getDimensions() noexcept {
-  return React::JSValueObject{
-      {"windowPhysicalPixels",
-       React::JSValueObject{
-           {"width", m_windowWidth * m_scale},
-           {"height", m_windowHeight * m_scale},
-           {"scale", m_scale},
-           {"fontScale", m_textScaleFactor},
-           {"densityDpi", m_dpi}}},
-      {"screenPhysicalPixels",
-       React::JSValueObject{
-           {"width", m_screenWidth},
-           {"height", m_screenHeight},
-           {"scale", m_scale},
-           {"fontScale", m_textScaleFactor},
-           {"densityDpi", m_dpi}}},
-  };
+ReactNativeSpecs::DeviceInfoSpec_DisplayMetricsAndroid DeviceInfoHolder::getWindow() noexcept {
+  ReactNativeSpecs::DeviceInfoSpec_DisplayMetricsAndroid metrics;
+  metrics.width = m_windowWidth * m_scale;
+  metrics.height = m_windowHeight * m_scale;
+  metrics.scale = m_scale;
+  metrics.fontScale = m_textScaleFactor;
+  metrics.densityDpi = m_dpi;
+  return metrics;
+}
+
+ReactNativeSpecs::DeviceInfoSpec_DisplayMetricsAndroid DeviceInfoHolder::getScreen() noexcept {
+  ReactNativeSpecs::DeviceInfoSpec_DisplayMetricsAndroid metrics;
+  metrics.width = m_screenWidth;
+  metrics.height = m_screenHeight;
+  metrics.scale = m_scale;
+  metrics.fontScale = m_textScaleFactor;
+  metrics.densityDpi = m_dpi;
+  return metrics;
+}
+
+ReactNativeSpecs::DeviceInfoSpec_DimensionsPayload DeviceInfoHolder::getDimensions() noexcept {
+  ReactNativeSpecs::DeviceInfoSpec_DimensionsPayload payload;
+  payload.windowPhysicalPixels = getWindow();
+  payload.screenPhysicalPixels = getScreen();
+  return payload;
 }
 
 void DeviceInfoHolder::SetCallback(
@@ -163,8 +173,10 @@ void DeviceInfoHolder::updateDeviceInfo() noexcept {
   }
 }
 
-void DeviceInfo::GetConstants(React::ReactConstantProvider &provider) noexcept {
-  provider.Add(L"Dimensions", DeviceInfoHolder::GetDimensions(m_context.Properties()));
+ReactNativeSpecs::DeviceInfoSpec_Constants DeviceInfo::GetConstants() noexcept {
+  ReactNativeSpecs::DeviceInfoSpec_Constants constants;
+  constants.Dimensions = DeviceInfoHolder::GetDimensions(m_context.Properties());
+  return constants;
 }
 
 void DeviceInfo::Initialize(React::ReactContext const &reactContext) noexcept {

package/Microsoft.ReactNative/Modules/DeviceInfoModule.h

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 #pragma once
 
+#include "../../codegen/NativeDeviceInfoSpec.g.h"
 #include <NativeModules.h>
 #include <React.h>
 #include <ReactNotificationService.h>
@@ -22,10 +23,13 @@ struct DeviceInfoHolder {
       const React::ReactPropertyBag &propertyBag,
       Mso::Functor<void(React::JSValueObject &&)> &&callback) noexcept;
   static void InitDeviceInfoHolder(const Mso::React::IReactContext &context) noexcept;
-  static React::JSValueObject GetDimensions(const React::ReactPropertyBag &propertyBag) noexcept;
+  static ReactNativeSpecs::DeviceInfoSpec_DimensionsPayload GetDimensions(
+      const React::ReactPropertyBag &propertyBag) noexcept;
 
  private:
-  React::JSValueObject getDimensions() noexcept;
+  ReactNativeSpecs::DeviceInfoSpec_DisplayMetricsAndroid getWindow() noexcept;
+  ReactNativeSpecs::DeviceInfoSpec_DisplayMetricsAndroid getScreen() noexcept;
+  ReactNativeSpecs::DeviceInfoSpec_DimensionsPayload getDimensions() noexcept;
   void updateDeviceInfo() noexcept;
   void notifyChanged() noexcept;
 
@@ -49,8 +53,8 @@ struct DeviceInfo : public std::enable_shared_from_this<DeviceInfo> {
   REACT_INIT(Initialize)
   void Initialize(React::ReactContext const &reactContext) noexcept;
 
-  REACT_CONSTANT_PROVIDER(GetConstants)
-  void GetConstants(React::ReactConstantProvider &provider) noexcept;
+  REACT_GET_CONSTANTS(GetConstants)
+  ReactNativeSpecs::DeviceInfoSpec_Constants GetConstants() noexcept;
 
  private:
   winrt::Microsoft::ReactNative::ReactContext m_context;

package/Microsoft.ReactNative/Modules/I18nManagerModule.cpp

@@ -61,7 +61,7 @@ void I18nManager::SwapLeftAndRightInRTL(bool /*flipStyles*/) noexcept {
   // TODO - https://github.com/microsoft/react-native-windows/issues/4662
 }
 
-void I18nManager::GetConstants(React::ReactConstantProvider &provider) noexcept {
+ReactNativeSpecs::I18nManagerSpec_Constants I18nManager::GetConstants() noexcept {
   std::string locale = "en-us";
 
   auto langs = winrt::Windows::Globalization::ApplicationLanguages::Languages();
@@ -69,9 +69,11 @@ void I18nManager::GetConstants(React::ReactConstantProvider &provider) noexcept
     locale = Microsoft::Common::Unicode::Utf16ToUtf8(langs.GetAt(0));
   }
 
-  provider.Add(L"localeIdentifier", locale);
-  provider.Add(L"doLeftAndRightSwapInRTL", false);
-  provider.Add(L"isRTL", IsRTL(m_context.Properties()));
+  ReactNativeSpecs::I18nManagerSpec_Constants constants;
+  constants.localeIdentifier = locale;
+  constants.doLeftAndRightSwapInRTL = false;
+  constants.isRTL = IsRTL(m_context.Properties());
+  return constants;
 }
 
 void I18nManager::Initialize(React::ReactContext const &reactContext) noexcept {

package/Microsoft.ReactNative/Modules/I18nManagerModule.h

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 #pragma once
 
+#include "../../codegen/NativeI18nManagerSpec.g.h"
 #include <NativeModules.h>
 #include <winrt/Windows.ApplicationModel.h>
 #include <winrt/Windows.Foundation.h>
@@ -20,8 +21,8 @@ struct I18nManager {
   REACT_INIT(Initialize)
   void Initialize(React::ReactContext const &reactContext) noexcept;
 
-  REACT_CONSTANT_PROVIDER(GetConstants)
-  void GetConstants(React::ReactConstantProvider &provider) noexcept;
+  REACT_GET_CONSTANTS(GetConstants)
+  ReactNativeSpecs::I18nManagerSpec_Constants GetConstants() noexcept;
 
   REACT_METHOD(AllowRTL, L"allowRTL")
   void AllowRTL(bool allowRTL) noexcept;

package/Microsoft.ReactNative/Modules/ImageViewManagerModule.cpp

@@ -23,39 +23,20 @@ using namespace xaml::Media::Imaging;
 } // namespace winrt
 
 namespace Microsoft::ReactNative {
-//
-// ImageViewManagerModule::ImageViewManagerModuleImpl
-//
-class ImageViewManagerModule::ImageViewManagerModuleImpl {
- public:
-  ImageViewManagerModuleImpl(ImageViewManagerModule *parent) : m_parent(parent) {}
-
-  void Disconnect() {
-    m_parent = nullptr;
-  }
-
-  void getSize(std::string uri, Callback successCallback, Callback errorCallback);
-  void getSizeWithHeaders(std::string uri, folly::dynamic &headers, Callback successCallback, Callback errorCallback);
-  void prefetchImage(std::string uri, Callback successCallback, Callback errorCallback);
-  void queryCache(const folly::dynamic &requests, Callback successCallback, Callback errorCallback);
-
- private:
-  ImageViewManagerModule *m_parent;
-};
 
 winrt::fire_and_forget GetImageSizeAsync(
     std::string uriString,
-    folly::dynamic &headers,
-    facebook::xplat::module::CxxModule::Callback successCallback,
-    facebook::xplat::module::CxxModule::Callback errorCallback) {
+    winrt::Microsoft::ReactNative::JSValue &&headers,
+    Mso::Functor<void(int32_t width, int32_t height)> successCallback,
+    Mso::Functor<void()> errorCallback) {
   bool succeeded{false};
 
   try {
     ReactImageSource source;
     source.uri = uriString;
-    if (!headers.isNull()) {
-      for (auto &header : headers.items()) {
-        source.headers.push_back(std::make_pair(header.first.asString(), header.second.asString()));
+    if (!headers.IsNull()) {
+      for (auto &header : headers.AsObject()) {
+        source.headers.push_back(std::make_pair(header.first, header.second.AsString()));
       }
     }
 
@@ -77,96 +58,67 @@ winrt::fire_and_forget GetImageSizeAsync(
     }
 
     if (bitmap) {
-      successCallback({folly::dynamic::array(bitmap.PixelWidth(), bitmap.PixelHeight())});
+      successCallback(bitmap.PixelWidth(), bitmap.PixelHeight());
       succeeded = true;
     }
   } catch (winrt::hresult_error const &) {
   }
 
   if (!succeeded)
-    errorCallback({});
+    errorCallback();
 
   co_return;
 }
 
-void ImageViewManagerModule::ImageViewManagerModuleImpl::getSize(
-    std::string uri,
-    Callback successCallback,
-    Callback errorCallback) {
-  folly::dynamic headers{};
-  GetImageSizeAsync(uri, headers, successCallback, errorCallback);
-}
-
-void ImageViewManagerModule::ImageViewManagerModuleImpl::getSizeWithHeaders(
-    std::string uri,
-    folly::dynamic &headers,
-    Callback successCallback,
-    Callback errorCallback) {
-  GetImageSizeAsync(uri, headers, successCallback, errorCallback);
+void ImageLoader::Initialize(React::ReactContext const &reactContext) noexcept {
+  m_context = reactContext;
 }
 
-void ImageViewManagerModule::ImageViewManagerModuleImpl::prefetchImage(
-    std::string /*uri*/,
-    Callback successCallback,
-    Callback /*errorCallback*/) {
-  // NotYetImplemented
-  successCallback({});
+void ImageLoader::getSize(std::string uri, React::ReactPromise<React::JSValue> &&result) noexcept {
+  getSizeWithHeaders(std::move(uri), {}, std::move(result));
 }
 
-void ImageViewManagerModule::ImageViewManagerModuleImpl::queryCache(
-    const folly::dynamic & /*requests*/,
-    Callback successCallback,
-    Callback /*errorCallback*/) {
-  // NotYetImplemented
-  successCallback({folly::dynamic::object()});
+void ImageLoader::getSizeWithHeaders(
+    std::string uri,
+    React::JSValue &&headers,
+    React::ReactPromise<React::JSValue> &&result) noexcept {
+  m_context.UIDispatcher().Post([context = m_context,
+                                 uri = std::move(uri),
+                                 headers = std::move(headers),
+                                 result = std::move(result)]() mutable noexcept {
+    GetImageSizeAsync(
+        std::move(uri),
+        std::move(headers),
+        [result, context](int32_t width, int32_t height) noexcept {
+          context.JSDispatcher().Post([result = std::move(result), width, height]() noexcept {
+            result.Resolve(React::JSValueArray{width, height});
+          });
+        },
+        [result, context]() noexcept {
+          context.JSDispatcher().Post([result = std::move(result)]() noexcept { result.Reject("Failed"); });
+        });
+  });
 }
 
-//
-// ImageViewManagerModule
-//
-const char *ImageViewManagerModule::name = "ImageLoader";
-
-ImageViewManagerModule::ImageViewManagerModule()
-    : m_imageViewManagerModule(std::make_shared<ImageViewManagerModuleImpl>(this)) {}
-
-ImageViewManagerModule::~ImageViewManagerModule() {}
-
-std::string ImageViewManagerModule::getName() {
-  return name;
+void ImageLoader::prefetchImage(std::string uri, React::ReactPromise<React::JSValue> &&result) noexcept {
+  // NYI
+  result.Resolve(true);
 }
 
-std::map<std::string, folly::dynamic> ImageViewManagerModule::getConstants() {
-  return {{}};
+void ImageLoader::prefetchImageWithMetadata(
+    std::string uri,
+    std::string queryRootName,
+    double rootTag,
+    React::ReactPromise<React::JSValue> &&result) noexcept {
+  // NYI
+  result.Resolve(true);
 }
 
-auto ImageViewManagerModule::getMethods() -> std::vector<Method> {
-  std::shared_ptr<ImageViewManagerModuleImpl> imageViewManager(m_imageViewManagerModule);
-  return {
-      Method(
-          "getSize",
-          [imageViewManager](folly::dynamic args, Callback successCallback, Callback errorCallback) {
-            imageViewManager->getSize(facebook::xplat::jsArgAsString(args, 0), successCallback, errorCallback);
-          }),
-      Method(
-          "getSizeWithHeaders",
-          [imageViewManager](folly::dynamic args, Callback successCallback, Callback errorCallback) {
-            imageViewManager->getSizeWithHeaders(
-                facebook::xplat::jsArgAsString(args, 0),
-                facebook::xplat::jsArgAsObject(args, 1),
-                successCallback,
-                errorCallback);
-          }),
-      Method(
-          "prefetchImage",
-          [imageViewManager](folly::dynamic args, Callback successCallback, Callback errorCallback) {
-            imageViewManager->prefetchImage(facebook::xplat::jsArgAsString(args, 0), successCallback, errorCallback);
-          }),
-      Method(
-          "queryCache",
-          [imageViewManager](folly::dynamic args, Callback successCallback, Callback errorCallback) {
-            imageViewManager->queryCache(args[0], successCallback, errorCallback);
-          }),
-  };
+void ImageLoader::queryCache(
+    std::vector<std::string> const &uris,
+    React::ReactPromise<React::JSValue> &&result) noexcept {
+  // NYI
+  result.Resolve(React::JSValueObject{});
 }
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/ImageViewManagerModule.h

@@ -2,31 +2,42 @@
 // Licensed under the MIT License.
 
 #pragma once
-#include <cxxreact/CxxModule.h>
 
-namespace facebook {
-namespace react {
-class MessageQueueThread;
-}
-} // namespace facebook
+#include "../../codegen/NativeImageLoaderIOSSpec.g.h"
+#include <NativeModules.h>
+#include <winrt/Windows.ApplicationModel.h>
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Graphics.Display.h>
 
 namespace Microsoft::ReactNative {
 
-class ImageViewManagerModule : public facebook::xplat::module::CxxModule {
- public:
-  ImageViewManagerModule();
-  virtual ~ImageViewManagerModule();
+REACT_MODULE(ImageLoader)
+struct ImageLoader {
+  REACT_INIT(Initialize)
+  void Initialize(React::ReactContext const &reactContext) noexcept;
 
-  // CxxModule
-  std::string getName() override;
-  std::map<std::string, folly::dynamic> getConstants() override;
-  auto getMethods() -> std::vector<Method> override;
+  REACT_METHOD(getSize)
+  void getSize(std::string uri, React::ReactPromise<React::JSValue> &&result) noexcept;
 
-  static const char *name;
+  REACT_METHOD(getSizeWithHeaders)
+  void
+  getSizeWithHeaders(std::string uri, React::JSValue &&headers, React::ReactPromise<React::JSValue> &&result) noexcept;
+
+  REACT_METHOD(prefetchImage)
+  void prefetchImage(std::string uri, React::ReactPromise<React::JSValue> &&result) noexcept;
+
+  REACT_METHOD(prefetchImageWithMetadata)
+  void prefetchImageWithMetadata(
+      std::string uri,
+      std::string queryRootName,
+      double rootTag,
+      React::ReactPromise<React::JSValue> &&result) noexcept;
+
+  REACT_METHOD(queryCache)
+  void queryCache(std::vector<std::string> const &uris, React::ReactPromise<React::JSValue> &&result) noexcept;
 
  private:
-  class ImageViewManagerModuleImpl;
-  std::shared_ptr<ImageViewManagerModuleImpl> m_imageViewManagerModule;
+  React::ReactContext m_context;
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/LinkingManagerModule.cpp

@@ -103,14 +103,24 @@ auto LinkingManagerModule::getMethods() -> std::vector<Method> {
       Method(
           "openURL",
           [](folly::dynamic args, Callback successCallback, Callback errorCallback) {
-            winrt::Windows::Foundation::Uri uri(Utf8ToUtf16(facebook::xplat::jsArgAsString(args, 0)));
-            openURLAsync(uri, successCallback, errorCallback);
+            auto inputUrl = facebook::xplat::jsArgAsString(args, 0);
+            try {
+              winrt::Windows::Foundation::Uri uri(Utf8ToUtf16(inputUrl));
+              openURLAsync(uri, successCallback, errorCallback);
+            } catch (winrt::hresult_error &e) {
+              errorCallback(
+                  {folly::dynamic::object("code", e.code().value)("message", "Unable to open URL: " + inputUrl)});
+            }
           }),
       Method(
           "canOpenURL",
           [](folly::dynamic args, Callback successCallback, Callback errorCallback) {
-            winrt::Windows::Foundation::Uri uri(Utf8ToUtf16(facebook::xplat::jsArgAsString(args, 0)));
-            canOpenURLAsync(uri, successCallback, errorCallback);
+            try {
+              winrt::Windows::Foundation::Uri uri(Utf8ToUtf16(facebook::xplat::jsArgAsString(args, 0)));
+              canOpenURLAsync(uri, successCallback, errorCallback);
+            } catch (winrt::hresult_error &e) {
+              successCallback({false});
+            }
           }),
       Method(
           "getInitialURL",

package/Microsoft.ReactNative/Modules/NativeUIManager.cpp

@@ -1070,7 +1070,7 @@ void NativeUIManager::findSubviewIn(
   ShadowNodeBase &node = static_cast<ShadowNodeBase &>(shadowNode);
   auto view = node.GetView();
 
-  auto rootUIView = view.as<xaml::UIElement>();
+  auto rootUIView = view.try_as<xaml::UIElement>();
   if (rootUIView == nullptr) {
     m_context.JSDispatcher().Post([callback = std::move(callback)]() { callback(0, 0, 0, 0, 0); });
     return;