react-native-windows 0.67.0 → 0.68.0-preview.1

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

@@ -120,10 +120,41 @@ void NativeAnimatedNodeManager::DisconnectAnimatedNode(int64_t parentNodeTag, in
   }
 }
 
-void NativeAnimatedNodeManager::StopAnimation(int64_t animationId) {
+void NativeAnimatedNodeManager::StopAnimation(int64_t animationId, bool isTrackingAnimation) {
   if (m_activeAnimations.count(animationId)) {
-    if (const auto animation = m_activeAnimations.at(animationId).get()) {
-      animation->StopAnimation();
+    if (const auto animation = m_activeAnimations.at(animationId)) {
+      animation->StopAnimation(isTrackingAnimation);
+
+      // Insert the animation into the pending completion set to ensure it is
+      // not destroyed before the callback occurs. It's safe to assume the
+      // scoped batch completion callback has not run, since if it had, the
+      // animation would have been removed from the set of active animations.
+      m_pendingCompletionAnimations.insert({animationId, animation});
+
+      const auto nodeTag = animation->AnimatedValueTag();
+      if (nodeTag != -1) {
+        const auto deferredAnimation = m_deferredAnimationForValues.find(nodeTag);
+        if (deferredAnimation != m_deferredAnimationForValues.end()) {
+          // We can assume that the currently deferred animation is the one
+          // being stopped given the constraint that only one animation can
+          // be active for a given value node.
+          assert(deferredAnimation->second == animationId);
+          // If the animation is deferred, just remove the deferred animation
+          // entry as two animations cannot animate the same value concurrently.
+          m_deferredAnimationForValues.erase(nodeTag);
+        } else {
+          // Since only one animation can be active at a time, there shouldn't
+          // be any stopped animations for the value node if the animation has
+          // not been deferred.
+          assert(!m_valuesWithStoppedAnimation.count(nodeTag));
+          // In this case, add the value tag to the set of values with stopped
+          // animations. This is used to optimize the lookup when determining
+          // if an animation needs to be deferred (rather than iterating over
+          // the map of pending completion animations).
+          m_valuesWithStoppedAnimation.insert(nodeTag);
+        }
+      }
+
       m_activeAnimations.erase(animationId);
     }
   }
@@ -218,12 +249,12 @@ void NativeAnimatedNodeManager::StartAnimatingNode(
     case AnimationType::Decay:
       m_activeAnimations.emplace(
           animationId,
-          std::make_unique<DecayAnimationDriver>(animationId, animatedNodeTag, endCallback, animationConfig, manager));
+          std::make_shared<DecayAnimationDriver>(animationId, animatedNodeTag, endCallback, animationConfig, manager));
       break;
     case AnimationType::Frames:
       m_activeAnimations.emplace(
           animationId,
-          std::make_unique<FrameAnimationDriver>(animationId, animatedNodeTag, endCallback, animationConfig, manager));
+          std::make_shared<FrameAnimationDriver>(animationId, animatedNodeTag, endCallback, animationConfig, manager));
       break;
     case AnimationType::Spring: {
       folly::dynamic dynamicValues = [animationConfig]() {
@@ -232,7 +263,7 @@ void NativeAnimatedNodeManager::StartAnimatingNode(
       }();
       m_activeAnimations.emplace(
           animationId,
-          std::make_unique<SpringAnimationDriver>(
+          std::make_shared<SpringAnimationDriver>(
               animationId, animatedNodeTag, endCallback, animationConfig, manager, dynamicValues));
       break;
     }
@@ -241,13 +272,17 @@ void NativeAnimatedNodeManager::StartAnimatingNode(
       break;
   }
 
+  // If the animated value node has any stopped animations, defer start until
+  // all stopped animations fire completion callback and have latest values.
   if (m_activeAnimations.count(animationId)) {
-    m_activeAnimations.at(animationId)->StartAnimation();
-
-    for (auto const &trackingAndLead : m_trackingAndLeadNodeTags) {
-      if (std::get<1>(trackingAndLead) == animatedNodeTag) {
-        RestartTrackingAnimatedNode(std::get<0>(trackingAndLead), std::get<1>(trackingAndLead), manager);
-      }
+    if (m_valuesWithStoppedAnimation.count(animatedNodeTag)) {
+      // Since only one animation can be active per value at a time, there will
+      // not be any other deferred animations for the value node.
+      assert(!m_deferredAnimationForValues.count(animatedNodeTag));
+      // Add the animation to the deferred animation map for the value tag.
+      m_deferredAnimationForValues.insert({animatedNodeTag, animationId});
+    } else {
+      StartAnimationAndTrackingNodes(animationId, animatedNodeTag, manager);
     }
   }
 }
@@ -406,4 +441,43 @@ TrackingAnimatedNode *NativeAnimatedNodeManager::GetTrackingAnimatedNode(int64_t
 void NativeAnimatedNodeManager::RemoveActiveAnimation(int64_t tag) {
   m_activeAnimations.erase(tag);
 }
+
+void NativeAnimatedNodeManager::RemoveStoppedAnimation(
+    int64_t tag,
+    const std::shared_ptr<NativeAnimatedNodeManager> &manager) {
+  if (m_pendingCompletionAnimations.count(tag)) {
+    // Remove stopped animation for value node entry
+    const auto animation = m_pendingCompletionAnimations.at(tag);
+    const auto nodeTag = animation->AnimatedValueTag();
+    // If the animation was stopped, attempt to start deferred animations.
+    if (m_valuesWithStoppedAnimation.erase(nodeTag)) {
+      StartDeferredAnimationsForValueNode(nodeTag, manager);
+    }
+    m_pendingCompletionAnimations.erase(tag);
+  }
+}
+
+void NativeAnimatedNodeManager::StartDeferredAnimationsForValueNode(
+    int64_t tag,
+    const std::shared_ptr<NativeAnimatedNodeManager> &manager) {
+  if (m_deferredAnimationForValues.count(tag)) {
+    const auto deferredAnimationTag = m_deferredAnimationForValues.at(tag);
+    StartAnimationAndTrackingNodes(deferredAnimationTag, tag, manager);
+    m_deferredAnimationForValues.erase(tag);
+  }
+}
+
+void NativeAnimatedNodeManager::StartAnimationAndTrackingNodes(
+    int64_t tag,
+    int64_t nodeTag,
+    const std::shared_ptr<NativeAnimatedNodeManager> &manager) {
+  if (m_activeAnimations.count(tag)) {
+    m_activeAnimations.at(tag)->StartAnimation();
+    for (auto const &trackingAndLead : m_trackingAndLeadNodeTags) {
+      if (std::get<1>(trackingAndLead) == nodeTag) {
+        RestartTrackingAnimatedNode(std::get<0>(trackingAndLead), std::get<1>(trackingAndLead), manager);
+      }
+    }
+  }
+}
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/Animated/NativeAnimatedNodeManager.h

@@ -49,7 +49,7 @@ class NativeAnimatedNodeManager {
   void DisconnectAnimatedNodeToView(int64_t propsNodeTag, int64_t viewTag);
   void ConnectAnimatedNode(int64_t parentNodeTag, int64_t childNodeTag);
   void DisconnectAnimatedNode(int64_t parentNodeTag, int64_t childNodeTag);
-  void StopAnimation(int64_t animationId);
+  void StopAnimation(int64_t animationId, bool isTrackingAnimation = false);
   void RestartTrackingAnimatedNode(
       int64_t animationId,
       int64_t animatedToValueTag,
@@ -88,7 +88,16 @@ class NativeAnimatedNodeManager {
   StyleAnimatedNode *GetStyleAnimatedNode(int64_t tag);
   TransformAnimatedNode *GetTransformAnimatedNode(int64_t tag);
   TrackingAnimatedNode *GetTrackingAnimatedNode(int64_t tag);
+
   void RemoveActiveAnimation(int64_t tag);
+  void RemoveStoppedAnimation(int64_t tag, const std::shared_ptr<NativeAnimatedNodeManager> &manager);
+  void StartDeferredAnimationsForValueNode(
+      int64_t valueNodeTag,
+      const std::shared_ptr<NativeAnimatedNodeManager> &manager);
+  void StartAnimationAndTrackingNodes(
+      int64_t tag,
+      int64_t nodeTag,
+      const std::shared_ptr<NativeAnimatedNodeManager> &manager);
 
  private:
   std::unordered_map<int64_t, std::unique_ptr<ValueAnimatedNode>> m_valueNodes{};
@@ -98,7 +107,10 @@ class NativeAnimatedNodeManager {
   std::unordered_map<int64_t, std::unique_ptr<TrackingAnimatedNode>> m_trackingNodes{};
   std::unordered_map<std::tuple<int64_t, std::string>, std::vector<std::unique_ptr<EventAnimationDriver>>>
       m_eventDrivers{};
-  std::unordered_map<int64_t, std::unique_ptr<AnimationDriver>> m_activeAnimations{};
+  std::unordered_map<int64_t, std::shared_ptr<AnimationDriver>> m_activeAnimations{};
+  std::unordered_map<int64_t, std::shared_ptr<AnimationDriver>> m_pendingCompletionAnimations{};
+  std::unordered_set<int64_t> m_valuesWithStoppedAnimation{};
+  std::unordered_map<int64_t, int64_t> m_deferredAnimationForValues{};
   std::vector<std::tuple<int64_t, int64_t>> m_trackingAndLeadNodeTags{};
   std::vector<int64_t> m_delayedPropsNodes{};
 

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

@@ -29,7 +29,10 @@ SpringAnimationDriver::SpringAnimationDriver(
   m_iterations = static_cast<int>(config.find(s_iterationsParameterName).dereference().second.asDouble());
 }
 
-bool SpringAnimationDriver::IsAnimationDone(double currentValue, double currentVelocity) {
+bool SpringAnimationDriver::IsAnimationDone(
+    double currentValue,
+    std::optional<double> /*previousValue*/,
+    double currentVelocity) {
   return (
       IsAtRest(currentVelocity, currentValue, m_endValue) ||
       (m_overshootClampingEnabled && IsOvershooting(currentValue)));

package/Microsoft.ReactNative/Modules/Animated/SpringAnimationDriver.h

@@ -22,7 +22,7 @@ class SpringAnimationDriver : public CalculatedAnimationDriver {
 
  protected:
   std::tuple<float, double> GetValueAndVelocityForTime(double time) override;
-  bool IsAnimationDone(double currentValue, double currentVelocity) override;
+  bool IsAnimationDone(double currentValue, std::optional<double> previousValue, double currentVelocity) override;
 
  private:
   bool IsAtRest(double currentVelocity, double currentPosition, double endValue);

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

@@ -27,6 +27,9 @@ void TrackingAnimatedNode::Update() {
 void TrackingAnimatedNode::StartAnimation() {
   if (auto const strongManager = m_manager.lock()) {
     if (auto const toValueNode = strongManager->GetValueAnimatedNode(m_toValueId)) {
+      // In case the animation is already running, we need to stop it to free up the
+      // animationId key in the active animations map in the animation manager.
+      strongManager->StopAnimation(m_animationId, true);
       toValueNode->AddActiveTrackingNode(m_tag);
       m_animationConfig.insert(static_cast<folly::StringPiece>(s_toValueIdName), toValueNode->Value());
       strongManager->StartTrackingAnimatedNode(

package/Microsoft.ReactNative/Modules/AppStateModule.h

@@ -11,6 +11,7 @@ namespace Microsoft::ReactNative {
 
 REACT_MODULE(AppState)
 struct AppState : public std::enable_shared_from_this<AppState> {
+  using ModuleSpec = ReactNativeSpecs::AppStateSpec;
   using AppStateChangeArgs = ReactNativeSpecs::AppStateSpec_getCurrentAppState_success_appState;
 
   REACT_INIT(Initialize)

package/Microsoft.ReactNative/Modules/AppThemeModuleUwp.cpp

@@ -29,17 +29,20 @@ using namespace winrt::Microsoft::ReactNative;
 
 namespace Microsoft::ReactNative {
 
+static const React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<AppThemeHolder>>>
+    &AppThemeHolderPropertyId() noexcept {
+  static const React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<AppThemeHolder>>> prop{
+      L"ReactNative.AppTheme", L"AppThemeHolder"};
+  return prop;
+}
+
 //
-// AppTheme
+// AppThemeHolder
 //
 
-AppTheme::AppTheme(
-    const Mso::React::IReactContext &context,
-    const std::shared_ptr<facebook::react::MessageQueueThread> &defaultQueueThread)
-    : m_context(&context), m_queueThread(defaultQueueThread) {
+AppThemeHolder::AppThemeHolder(const Mso::React::IReactContext &context) : m_context(&context) {
   if (auto currentApp = xaml::TryGetCurrentApplication()) {
-    m_isHighContrast = getIsHighContrast();
-    m_highContrastColors = getHighContrastColors();
+    NotifyHighContrastChanged();
 
     if (IsWinUI3Island()) {
       m_wmSubscription = SubscribeToWindowMessage(
@@ -53,57 +56,69 @@ AppTheme::AppTheme(
   }
 }
 
-bool AppTheme::getIsHighContrast() const {
-  return m_accessibilitySettings.HighContrast();
+ReactNativeSpecs::AppThemeSpec_AppThemeData AppThemeHolder::GetConstants() noexcept {
+  return m_appThemeData;
 }
 
-// Returns the RBG values for the 8 relevant High Contrast elements.
-folly::dynamic AppTheme::getHighContrastColors() const {
-  winrt::Windows::UI::Color ButtonFaceColor = m_uiSettings.UIElementColor(winrt::UIElementType::ButtonFace);
-  winrt::Windows::UI::Color ButtonTextColor = m_uiSettings.UIElementColor(winrt::UIElementType::ButtonText);
-  winrt::Windows::UI::Color GrayTextColor = m_uiSettings.UIElementColor(winrt::UIElementType::GrayText);
-  winrt::Windows::UI::Color HighlightColor = m_uiSettings.UIElementColor(winrt::UIElementType::Highlight);
-  winrt::Windows::UI::Color HighlightTextColor = m_uiSettings.UIElementColor(winrt::UIElementType::HighlightText);
-  winrt::Windows::UI::Color HotlightColor = m_uiSettings.UIElementColor(winrt::UIElementType::Hotlight);
-  winrt::Windows::UI::Color WindowColor = m_uiSettings.UIElementColor(winrt::UIElementType::Window);
-  winrt::Windows::UI::Color WindowTextColor = m_uiSettings.UIElementColor(winrt::UIElementType::WindowText);
-
-  folly::dynamic rbgValues = folly::dynamic::object("ButtonFaceColor", formatRGB(ButtonFaceColor))(
-      "ButtonTextColor", formatRGB(ButtonTextColor))("GrayTextColor", formatRGB(GrayTextColor))(
-      "HighlightColor", formatRGB(HighlightColor))("HighlightTextColor", formatRGB(HighlightTextColor))(
-      "HotlightColor", formatRGB(HotlightColor))("WindowColor", formatRGB(WindowColor))(
-      "WindowTextColor", formatRGB(WindowTextColor));
-  return rbgValues;
+/*static*/ void AppThemeHolder::InitAppThemeHolder(const Mso::React::IReactContext &context) noexcept {
+  auto appThemeHolder = std::make_shared<AppThemeHolder>(context);
+  winrt::Microsoft::ReactNative::ReactPropertyBag pb{context.Properties()};
+  pb.Set(AppThemeHolderPropertyId(), std::move(appThemeHolder));
 }
 
-/*static*/ std::string AppTheme::formatRGB(winrt::Windows::UI::Color ElementColor) {
-  char colorChars[8];
-  sprintf_s(colorChars, "#%02x%02x%02x", ElementColor.R, ElementColor.G, ElementColor.B);
-  return colorChars;
-}
+void AppThemeHolder::SetCallback(
+    const React::ReactPropertyBag &propertyBag,
+    Mso::Functor<void(React::JSValueObject &&)> &&callback) noexcept {
+  auto holder = propertyBag.Get(AppThemeHolderPropertyId());
 
-void AppTheme::fireEvent(std::string const &eventName, folly::dynamic &&eventData) const {
-  m_context->CallJSFunction("RCTDeviceEventEmitter", "emit", folly::dynamic::array(eventName, std::move(eventData)));
+  (*holder)->m_notifyCallback = std::move(callback);
 }
 
-void AppTheme::NotifyHighContrastChanged() const {
-  folly::dynamic eventData =
-      folly::dynamic::object("highContrastColors", getHighContrastColors())("isHighContrast", getIsHighContrast());
-  this->
+void AppThemeHolder::NotifyHighContrastChanged() noexcept {
+  m_appThemeData.isHighContrast = m_accessibilitySettings.HighContrast();
+  m_appThemeData.highContrastColors.ButtonFaceColor =
+      FormatRGB(m_uiSettings.UIElementColor(winrt::UIElementType::ButtonFace));
+  m_appThemeData.highContrastColors.ButtonTextColor =
+      FormatRGB(m_uiSettings.UIElementColor(winrt::UIElementType::ButtonText));
+  m_appThemeData.highContrastColors.GrayTextColor =
+      FormatRGB(m_uiSettings.UIElementColor(winrt::UIElementType::GrayText));
+  m_appThemeData.highContrastColors.HighlightColor =
+      FormatRGB(m_uiSettings.UIElementColor(winrt::UIElementType::Highlight));
+  m_appThemeData.highContrastColors.HighlightTextColor =
+      FormatRGB(m_uiSettings.UIElementColor(winrt::UIElementType::HighlightText));
+  m_appThemeData.highContrastColors.HotlightColor =
+      FormatRGB(m_uiSettings.UIElementColor(winrt::UIElementType::Hotlight));
+  m_appThemeData.highContrastColors.WindowColor = FormatRGB(m_uiSettings.UIElementColor(winrt::UIElementType::Window));
+  m_appThemeData.highContrastColors.WindowTextColor =
+      FormatRGB(m_uiSettings.UIElementColor(winrt::UIElementType::WindowText));
+
+  if (m_notifyCallback) {
+    auto writer = MakeJSValueTreeWriter();
+    WriteValue(writer, m_appThemeData);
+    m_notifyCallback(TakeJSValue(writer).MoveObject());
+  }
+}
 
-      fireEvent("highContrastChanged", std::move(eventData));
+/*static*/ std::string AppThemeHolder::FormatRGB(winrt::Windows::UI::Color ElementColor) {
+  char colorChars[8];
+  sprintf_s(colorChars, "#%02x%02x%02x", ElementColor.R, ElementColor.G, ElementColor.B);
+  return colorChars;
 }
 
-AppThemeModule::AppThemeModule(std::shared_ptr<AppTheme> &&appTheme) : m_appTheme(std::move(appTheme)) {}
+void AppTheme::Initialize(React::ReactContext const &reactContext) noexcept {
+  m_context = reactContext;
 
-auto AppThemeModule::getConstants() -> std::map<std::string, folly::dynamic> {
-  return {
-      {"initialHighContrast", folly::dynamic{m_appTheme->getIsHighContrast()}},
-      {"initialHighContrastColors", folly::dynamic{m_appTheme->getHighContrastColors()}}};
+  AppThemeHolder::SetCallback(
+      m_context.Properties(), [weakThis = weak_from_this()](React::JSValueObject &&appThemeInfo) {
+        if (auto strongThis = weakThis.lock()) {
+          strongThis->m_context.EmitJSEvent(L"RCTDeviceEventEmitter", L"highContrastChanged", appThemeInfo);
+        }
+      });
 }
 
-auto AppThemeModule::getMethods() -> std::vector<facebook::xplat::module::CxxModule::Method> {
-  return {};
+ReactNativeSpecs::AppThemeSpec_AppThemeData AppTheme::GetConstants() noexcept {
+  winrt::Microsoft::ReactNative::ReactPropertyBag pb{m_context.Properties()};
+  return (*pb.Get(AppThemeHolderPropertyId()))->GetConstants();
 }
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/AppThemeModuleUwp.h

@@ -9,48 +9,47 @@
 #include <cxxreact/MessageQueueThread.h>
 #include <winrt/Windows.UI.ViewManagement.h>
 
+#include "../../codegen/NativeAppThemeSpec.g.h"
+#include <NativeModules.h>
+
 namespace Microsoft::ReactNative {
 
-class AppTheme : public std::enable_shared_from_this<AppTheme> {
+class AppThemeHolder {
  public:
-  AppTheme(
-      const Mso::React::IReactContext &reactContext,
-      const std::shared_ptr<facebook::react::MessageQueueThread> &defaultQueueThread);
+  AppThemeHolder(const Mso::React::IReactContext &reactContext);
 
-  bool getIsHighContrast() const;
-  folly::dynamic getHighContrastColors() const;
+  static void InitAppThemeHolder(const Mso::React::IReactContext &context) noexcept;
+  ReactNativeSpecs::AppThemeSpec_AppThemeData GetConstants() noexcept;
+  static void SetCallback(
+      const React::ReactPropertyBag &propertyBag,
+      Mso::Functor<void(React::JSValueObject &&)> &&callback) noexcept;
 
  private:
   // High Contrast Color helper method
-  static std::string formatRGB(winrt::Windows::UI::Color ElementColor);
-  void NotifyHighContrastChanged() const;
-  void fireEvent(std::string const &eventName, folly::dynamic &&eventData) const;
+  static std::string FormatRGB(winrt::Windows::UI::Color ElementColor);
+  void NotifyHighContrastChanged() noexcept;
 
   Mso::CntPtr<const Mso::React::IReactContext> m_context;
-  std::shared_ptr<facebook::react::MessageQueueThread> m_queueThread;
-  bool m_isHighContrast{false};
-  folly::dynamic m_highContrastColors;
+  Mso::Functor<void(React::JSValueObject &&)> m_notifyCallback;
+  ReactNativeSpecs::AppThemeSpec_AppThemeData m_appThemeData;
   winrt::Windows::UI::ViewManagement::AccessibilitySettings m_accessibilitySettings{};
   winrt::Windows::UI::ViewManagement::AccessibilitySettings::HighContrastChanged_revoker m_highContrastChangedRevoker{};
   winrt::Windows::UI::ViewManagement::UISettings m_uiSettings{};
   winrt::Microsoft::ReactNative::ReactNotificationSubscription m_wmSubscription;
 };
 
-class AppThemeModule : public facebook::xplat::module::CxxModule {
- public:
-  static constexpr const char *Name = "RTCAppTheme";
+REACT_MODULE(AppTheme)
+struct AppTheme : public std::enable_shared_from_this<AppTheme> {
+  using ModuleSpec = ReactNativeSpecs::AppThemeSpec;
 
-  AppThemeModule(std::shared_ptr<AppTheme> &&appTheme);
+  REACT_GET_CONSTANTS(GetConstants)
+  ReactNativeSpecs::AppThemeSpec_AppThemeData GetConstants() noexcept;
 
-  // CxxModule
-  std::string getName() override {
-    return Name;
-  };
-  auto getConstants() -> std::map<std::string, folly::dynamic> override;
-  auto getMethods() -> std::vector<Method> override;
+  REACT_INIT(Initialize)
+  void Initialize(React::ReactContext const &reactContext) noexcept;
 
  private:
-  std::shared_ptr<AppTheme> m_appTheme;
+  winrt::Microsoft::ReactNative::ReactContext m_context;
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/ClipboardModule.h

@@ -2,12 +2,15 @@
 // Licensed under the MIT License.
 #pragma once
 
+#include "../../codegen/NativeClipboardSpec.g.h"
 #include <NativeModules.h>
 
 namespace Microsoft::ReactNative {
 
 REACT_MODULE(Clipboard)
 struct Clipboard {
+  using ModuleSpec = ReactNativeSpecs::ClipboardSpec;
+
   REACT_INIT(Initialize)
   void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 

package/Microsoft.ReactNative/Modules/DevSettingsModule.h

@@ -5,6 +5,7 @@
 #include <cxxreact/CxxModule.h>
 #include <functional/functor.h>
 
+#include "../../codegen/NativeDevSettingsSpec.g.h"
 #include <NativeModules.h>
 #include <ReactHost/React.h>
 
@@ -12,6 +13,8 @@ namespace Microsoft::ReactNative {
 
 REACT_MODULE(DevSettings)
 struct DevSettings {
+  using ModuleSpec = ReactNativeSpecs::DevSettingsSpec;
+
   REACT_INIT(Initialize) void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 
   REACT_METHOD(reload) void reload() noexcept;

package/Microsoft.ReactNative/Modules/DeviceInfoModule.h

@@ -50,6 +50,8 @@ struct DeviceInfoHolder {
 
 REACT_MODULE(DeviceInfo)
 struct DeviceInfo : public std::enable_shared_from_this<DeviceInfo> {
+  using ModuleSpec = ReactNativeSpecs::DeviceInfoSpec;
+
   REACT_INIT(Initialize)
   void Initialize(React::ReactContext const &reactContext) noexcept;
 

package/Microsoft.ReactNative/Modules/I18nManagerModule.h

@@ -15,6 +15,8 @@ namespace Microsoft::ReactNative {
 // PropertyBag so that the I18nModule can return the constants synchronously.
 REACT_MODULE(I18nManager)
 struct I18nManager {
+  using ModuleSpec = ReactNativeSpecs::I18nManagerSpec;
+
   static void InitI18nInfo(const React::ReactPropertyBag &propertyBag) noexcept;
   static bool IsRTL(const React::ReactPropertyBag &propertyBag) noexcept;
 

package/Microsoft.ReactNative/Modules/ImageViewManagerModule.h

@@ -13,6 +13,8 @@ namespace Microsoft::ReactNative {
 
 REACT_MODULE(ImageLoader)
 struct ImageLoader {
+  using ModuleSpec = ReactNativeSpecs::ImageLoaderIOSSpec;
+
   REACT_INIT(Initialize)
   void Initialize(React::ReactContext const &reactContext) noexcept;