react-native-windows 0.70.8 → 0.71.0-preview.1

package/Microsoft.ReactNative/Modules/NativeUIManager.h

@@ -15,6 +15,7 @@
 #include <nativemodules.h>
 #include <map>
 #include <memory>
+#include <unordered_map>
 #include <vector>
 
 namespace Microsoft::ReactNative {
@@ -55,6 +56,7 @@ class NativeUIManager final : public INativeUIManager {
   void UpdateView(ShadowNode &shadowNode, winrt::Microsoft::ReactNative::JSValueObject &props) override;
   void onBatchComplete() override;
   void ensureInBatch() override;
+  bool isInBatch() override;
   void measure(
       ShadowNode &shadowNode,
       ShadowNode &shadowRoot,
@@ -99,9 +101,11 @@ class NativeUIManager final : public INativeUIManager {
 
   int64_t AddMeasuredRootView(facebook::react::IReactRootView *rootView);
 
- private:
   void DoLayout();
-  void UpdateExtraLayout(int64_t tag);
+  void ApplyLayout(int64_t tag, float width = YGUndefined, float height = YGUndefined);
+
+ private:
+  void SetLayoutPropsRecursive(int64_t tag);
   YGNodeRef GetYogaNode(int64_t tag) const;
 
   winrt::weak_ref<winrt::Microsoft::ReactNative::ReactRootView> GetParentXamlReactControl(int64_t tag) const;
@@ -112,8 +116,8 @@ class NativeUIManager final : public INativeUIManager {
   YGConfigRef m_yogaConfig;
   bool m_inBatch = false;
 
-  std::map<int64_t, YogaNodePtr> m_tagsToYogaNodes;
-  std::map<int64_t, std::unique_ptr<YogaContext>> m_tagsToYogaContext;
+  std::unordered_map<int64_t, YogaNodePtr> m_tagsToYogaNodes;
+  std::unordered_map<int64_t, std::unique_ptr<YogaContext>> m_tagsToYogaContext;
   std::vector<xaml::FrameworkElement::SizeChanged_revoker> m_sizeChangedVector;
   std::vector<std::function<void()>> m_batchCompletedCallbacks;
   std::vector<int64_t> m_extraLayoutNodes;

package/Microsoft.ReactNative/Modules/PaperUIManagerModule.cpp

@@ -80,6 +80,11 @@ std::weak_ptr<NativeUIManager> GetNativeUIManager(const Mso::React::IReactContex
   return v ? v.Value() : std::weak_ptr<NativeUIManager>{};
 }
 
+std::weak_ptr<NativeUIManager> GetNativeUIManager(const winrt::Microsoft::ReactNative::ReactContext &context) {
+  auto v = context.Properties().Get(NativeUIManagerProperty());
+  return v ? v.Value() : std::weak_ptr<NativeUIManager>{};
+}
+
 class UIManagerModule : public std::enable_shared_from_this<UIManagerModule>, public INativeUIManagerHost {
  public:
   UIManagerModule() {}
@@ -113,7 +118,7 @@ class UIManagerModule : public std::enable_shared_from_this<UIManagerModule>, pu
     writer.WriteObjectEnd();
 
     auto val = TakeJSValue(writer);
-    return std::move(val.AsObject().Copy()); // Lame why do we need to copy?
+    return std::move(val.AsObject().Copy()); // Why do we need to copy?
   }
 
   void ConstantsViaConstantsProvider(winrt::Microsoft::ReactNative::ReactConstantProvider &constants) noexcept {
@@ -200,20 +205,7 @@ class UIManagerModule : public std::enable_shared_from_this<UIManagerModule>, pu
       std::function<void(double left, double top, double width, double height, double pageX, double pageY)>
           &&callback) noexcept {
     if (auto node = m_nodeRegistry.findNode(reactTag)) {
-      int64_t rootTag = reactTag;
-      while (true) {
-        if (auto currNode = m_nodeRegistry.findNode(rootTag)) {
-          if (currNode->m_parent == -1) {
-            break;
-          }
-          rootTag = currNode->m_parent;
-        } else {
-          callback(0, 0, 0, 0, 0, 0);
-          return;
-        }
-      }
-      auto &rootNode = m_nodeRegistry.getNode(rootTag);
-
+      auto &rootNode = m_nodeRegistry.getNode(node->m_rootTag);
       m_nativeUIManager->measure(*node, rootNode, std::move(callback));
     }
   }
@@ -379,10 +371,6 @@ class UIManagerModule : public std::enable_shared_from_this<UIManagerModule>, pu
     return m_nodeRegistry.findNode(tag);
   }
 
-  ShadowNode *FindParentRootShadowNode(int64_t tag) {
-    return m_nodeRegistry.getParentRootShadowNode(tag);
-  }
-
   ShadowNode &GetShadowNodeForTag(int64_t tag) {
     return m_nodeRegistry.getNode(tag);
   }

package/Microsoft.ReactNative/Modules/PaperUIManagerModule.h

@@ -29,6 +29,7 @@ struct UIManagerSettings {
 };
 
 std::weak_ptr<NativeUIManager> GetNativeUIManager(const Mso::React::IReactContext &context);
+std::weak_ptr<NativeUIManager> GetNativeUIManager(const winrt::Microsoft::ReactNative::ReactContext &context);
 
 REACT_MODULE(UIManager)
 struct UIManager final {

package/Microsoft.ReactNative/Modules/TimingModule.cpp

@@ -9,11 +9,7 @@
 #include <InstanceManager.h>
 #include <UI.Xaml.Media.h>
 #include <Utils/ValueUtils.h>
-
-#include <cxxreact/CxxModule.h>
-#include <cxxreact/Instance.h>
-
-#include <cxxreact/JsArgumentHelpers.h>
+#include <XamlUtils.h>
 
 #include <unknwnbase.h>
 
@@ -75,22 +71,13 @@ bool TimerQueue::IsEmpty() {
 // Timing
 //
 
-Timing::Timing(TimingModule *parent) : m_parent(parent) {}
-
-void Timing::Disconnect() {
-  m_parent = nullptr;
-  StopTicks();
-}
-
-std::weak_ptr<facebook::react::Instance> Timing::getInstance() noexcept {
-  if (!m_parent)
-    return std::weak_ptr<facebook::react::Instance>();
-
-  return m_parent->getInstance();
+void Timing::Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept {
+  m_context = reactContext;
+  m_usePostForRendering = !xaml::TryGetCurrentApplication();
 }
 
 void Timing::OnTick() {
-  std::vector<int64_t> readyTimers;
+  winrt::Microsoft::ReactNative::JSValueArray readyTimers;
   auto now = TDateTime::clock::now();
 
   auto emittedAnimationFrame = false;
@@ -109,6 +96,8 @@ void Timing::OnTick() {
 
   if (m_timerQueue.IsEmpty()) {
     StopTicks();
+  } else if (m_usePostForRendering && m_usingRendering && emittedAnimationFrame) {
+    PostRenderFrame(); // Repost
   } else if (!m_usingRendering || !emittedAnimationFrame) {
     // If we're using a rendering callback, check if any animation frame
     // requests were emitted in this tick. If not, start the dispatcher timer.
@@ -118,15 +107,8 @@ void Timing::OnTick() {
   }
 
   if (!readyTimers.empty()) {
-    if (auto instance = getInstance().lock()) {
-      // Package list of Timer Ids to fire in a dynamic array to pass as
-      // parameter
-      folly::dynamic params = folly::dynamic::array();
-      for (size_t i = 0, c = readyTimers.size(); i < c; ++i)
-        params.push_back(folly::dynamic(readyTimers[i]));
-
-      instance->callJSFunction("JSTimers", "callTimers", folly::dynamic::array(params));
-    }
+    m_context.CallJSFunction(
+        L"JSTimers", L"callTimers", winrt::Microsoft::ReactNative::JSValueArray{std::move(readyTimers)});
   }
 }
 
@@ -144,10 +126,25 @@ winrt::dispatching::DispatcherQueueTimer Timing::EnsureDispatcherTimer() {
   return m_dispatcherQueueTimer;
 }
 
+void Timing::PostRenderFrame() noexcept {
+  assert(m_usePostForRendering);
+  m_usingRendering = true;
+  m_context.UIDispatcher().Post([wkThis = std::weak_ptr(this->shared_from_this())]() {
+    if (auto pThis = wkThis.lock()) {
+      pThis->m_usingRendering = false;
+      pThis->OnTick();
+    }
+  });
+}
+
 void Timing::StartRendering() {
   if (m_dispatcherQueueTimer)
     m_dispatcherQueueTimer.Stop();
 
+  if (m_usePostForRendering) {
+    PostRenderFrame();
+    return;
+  }
   m_rendering.revoke();
   m_usingRendering = true;
   m_rendering = xaml::Media::CompositionTarget::Rendering(
@@ -176,12 +173,12 @@ void Timing::StopTicks() {
     m_dispatcherQueueTimer.Stop();
 }
 
-void Timing::createTimer(int64_t id, double duration, double jsSchedulingTime, bool repeat) {
+void Timing::createTimerOnQueue(int64_t id, double duration, double jsSchedulingTime, bool repeat) noexcept {
   if (duration == 0 && !repeat) {
-    if (auto instance = getInstance().lock()) {
-      folly::dynamic params = folly::dynamic::array(id);
-      instance->callJSFunction("JSTimers", "callTimers", folly::dynamic::array(params));
-    }
+    m_context.CallJSFunction(
+        L"JSTimers",
+        L"callTimers",
+        winrt::Microsoft::ReactNative::JSValueArray{winrt::Microsoft::ReactNative::JSValueArray{id}});
 
     return;
   }
@@ -201,68 +198,32 @@ void Timing::createTimer(int64_t id, double duration, double jsSchedulingTime, b
   }
 }
 
-void Timing::deleteTimer(int64_t id) {
+void Timing::createTimer(double id, double duration, double jsSchedulingTime, bool repeat) noexcept {
+  winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::PostToUIBatchingQueue(
+      m_context.Handle(), [wkThis = std::weak_ptr(this->shared_from_this()), id, duration, jsSchedulingTime, repeat]() {
+        if (auto pThis = wkThis.lock()) {
+          pThis->createTimerOnQueue(static_cast<int64_t>(id), duration, jsSchedulingTime, repeat);
+        }
+      });
+}
+
+void Timing::deleteTimerOnQueue(int64_t id) noexcept {
   m_timerQueue.Remove(id);
   if (m_timerQueue.IsEmpty())
     StopTicks();
 }
 
-void Timing::setSendIdleEvents(bool /*sendIdleEvents*/) {
-  // TODO: Implement.
-}
-
-//
-// TimingModule
-//
-const char *TimingModule::name = "Timing";
-
-TimingModule::TimingModule() : m_timing(std::make_shared<Timing>(this)) {}
-
-TimingModule::~TimingModule() {
-  if (m_timing != nullptr)
-    m_timing->Disconnect();
-}
-
-std::string TimingModule::getName() {
-  return name;
-}
-
-auto TimingModule::getConstants() -> std::map<std::string, dynamic> {
-  return {};
+void Timing::deleteTimer(double id) noexcept {
+  winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::PostToUIBatchingQueue(
+      m_context.Handle(), [wkThis = std::weak_ptr(this->shared_from_this()), id]() {
+        if (auto pThis = wkThis.lock()) {
+          pThis->deleteTimerOnQueue(static_cast<int64_t>(id));
+        }
+      });
 }
 
-auto TimingModule::getMethods() -> std::vector<Method> {
-  std::shared_ptr<Timing> timing(m_timing);
-  return {
-      Method(
-          "createTimer",
-          [timing](dynamic args) // int64_t id, double duration, double
-                                 // jsSchedulingTime, bool repeat
-          {
-            timing->createTimer(
-                jsArgAsInt(args, 0), jsArgAsDouble(args, 1), jsArgAsDouble(args, 2), jsArgAsBool(args, 3));
-          }),
-      Method(
-          "deleteTimer",
-          [timing](dynamic args) // int64_t code, const std::string& reason,
-                                 // int64_t id
-          { timing->deleteTimer(jsArgAsInt(args, 0)); }),
-      Method(
-          "setSendIdleEvents",
-          [timing](dynamic args) // const std::string& message, int64_t id
-          { timing->setSendIdleEvents(jsArgAsBool(args, 0)); }),
-  };
+void Timing::setSendIdleEvents(bool /*sendIdleEvents*/) noexcept {
+  // TODO: Implement.
 }
 
 } // namespace Microsoft::ReactNative
-
-namespace facebook {
-namespace react {
-
-std::unique_ptr<facebook::xplat::module::CxxModule> CreateTimingModule(
-    const std::shared_ptr<facebook::react::MessageQueueThread> &) noexcept {
-  return std::make_unique<Microsoft::ReactNative::TimingModule>();
-}
-
-} // namespace react
-} // namespace facebook

package/Microsoft.ReactNative/Modules/TimingModule.h

@@ -3,15 +3,10 @@
 
 #pragma once
 
-#include <CppWinRTIncludes.h>
-#include <cxxreact/CxxModule.h>
-#include <cxxreact/MessageQueueThread.h>
+#include "../../codegen/NativeTimingSpec.g.h"
 
-#include <folly/dynamic.h>
-#include <memory>
-#include <vector>
+#include <ReactCoreInjection.h>
 
-#include <winrt/Windows.Foundation.h>
 namespace Microsoft::ReactNative {
 
 typedef winrt::Windows::Foundation::DateTime TDateTime;
@@ -56,43 +51,38 @@ class TimerQueue {
   std::vector<Timer> m_timerVector;
 };
 
-class Timing : public std::enable_shared_from_this<Timing> {
+REACT_MODULE(Timing)
+struct Timing : public std::enable_shared_from_this<Timing> {
+  using ModuleSpec = ReactNativeSpecs::TimingSpec;
+
  public:
-  Timing(TimingModule *parent);
-  void Disconnect();
+  REACT_INIT(Initialize)
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
+
+  REACT_METHOD(createTimer)
+  void createTimer(double id, double duration, double jsSchedulingTime, bool repeat) noexcept;
 
-  void createTimer(int64_t id, double duration, double jsSchedulingTime, bool repeat);
-  void deleteTimer(int64_t id);
-  void setSendIdleEvents(bool sendIdleEvents);
+  REACT_METHOD(deleteTimer)
+  void deleteTimer(double id) noexcept;
+  REACT_METHOD(setSendIdleEvents)
+  void setSendIdleEvents(bool sendIdleEvents) noexcept;
 
  private:
-  std::weak_ptr<facebook::react::Instance> getInstance() noexcept;
+  void createTimerOnQueue(int64_t id, double duration, double jsSchedulingTime, bool repeat) noexcept;
+  void deleteTimerOnQueue(int64_t id) noexcept;
   void OnTick();
   winrt::dispatching::DispatcherQueueTimer EnsureDispatcherTimer();
   void StartRendering();
+  void PostRenderFrame() noexcept;
   void StartDispatcherTimer();
   void StopTicks();
 
- private:
-  TimingModule *m_parent;
+  React::ReactContext m_context;
   TimerQueue m_timerQueue;
   xaml::Media::CompositionTarget::Rendering_revoker m_rendering;
   winrt::dispatching::DispatcherQueueTimer m_dispatcherQueueTimer{nullptr};
   bool m_usingRendering{false};
-};
-
-class TimingModule : public facebook::xplat::module::CxxModule {
- public:
-  TimingModule();
-  ~TimingModule();
-  std::string getName();
-  virtual auto getConstants() -> std::map<std::string, folly::dynamic>;
-  virtual auto getMethods() -> std::vector<Method>;
-
-  static const char *name;
-
- private:
-  std::shared_ptr<Timing> m_timing;
+  bool m_usePostForRendering{false};
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/QuirkSettings.cpp

@@ -25,6 +25,18 @@ winrt::Microsoft::ReactNative::ReactPropertyId<bool> MatchAndroidAndIOSStretchBe
   properties.Set(MatchAndroidAndIOSStretchBehaviorProperty(), value);
 }
 
+winrt::Microsoft::ReactNative::ReactPropertyId<bool> UseWebFlexBasisBehaviorProperty() noexcept {
+  static winrt::Microsoft::ReactNative::ReactPropertyId<bool> propId{
+      L"ReactNative.QuirkSettings", L"UseWebFlexBasisBehavior"};
+  return propId;
+}
+
+/*static*/ void QuirkSettings::SetUseWebFlexBasisBehavior(
+    winrt::Microsoft::ReactNative::ReactPropertyBag properties,
+    bool value) noexcept {
+  properties.Set(UseWebFlexBasisBehaviorProperty(), value);
+}
+
 winrt::Microsoft::ReactNative::ReactPropertyId<bool> AcceptSelfSignedCertsProperty() noexcept {
   winrt::Microsoft::ReactNative::ReactPropertyId<bool> propId{
       L"ReactNative.QuirkSettings", L"Networking.AcceptSelfSigned"};
@@ -60,6 +72,12 @@ winrt::Microsoft::ReactNative::ReactPropertyId<bool> MapWindowDeactivatedToAppSt
   SetMatchAndroidAndIOSStretchBehavior(ReactPropertyBag(settings.Properties()), value);
 }
 
+/*static*/ void QuirkSettings::SetUseWebFlexBasisBehavior(
+    winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
+    bool value) noexcept {
+  SetUseWebFlexBasisBehavior(ReactPropertyBag(settings.Properties()), value);
+}
+
 /*static*/ void QuirkSettings::SetAcceptSelfSigned(
     winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
     bool value) noexcept {
@@ -84,6 +102,10 @@ winrt::Microsoft::ReactNative::ReactPropertyId<bool> MapWindowDeactivatedToAppSt
   return properties.Get(MatchAndroidAndIOSStretchBehaviorProperty()).value_or(true);
 }
 
+/*static*/ bool QuirkSettings::GetUseWebFlexBasisBehavior(ReactPropertyBag properties) noexcept {
+  return properties.Get(UseWebFlexBasisBehaviorProperty()).value_or(false);
+}
+
 /*static*/ bool QuirkSettings::GetAcceptSelfSigned(ReactPropertyBag properties) noexcept {
   return properties.Get(AcceptSelfSignedCertsProperty()).value_or(false);
 }

package/Microsoft.ReactNative/QuirkSettings.h

@@ -20,6 +20,11 @@ struct QuirkSettings : QuirkSettingsT<QuirkSettings> {
       bool value) noexcept;
   static bool GetMatchAndroidAndIOSStretchBehavior(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
 
+  static void SetUseWebFlexBasisBehavior(
+      winrt::Microsoft::ReactNative::ReactPropertyBag properties,
+      bool value) noexcept;
+  static bool GetUseWebFlexBasisBehavior(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
+
   static bool GetAcceptSelfSigned(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
   static winrt::Microsoft::ReactNative::BackNavigationHandlerKind GetBackHandlerKind(
       winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
@@ -37,6 +42,10 @@ struct QuirkSettings : QuirkSettingsT<QuirkSettings> {
       winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
       bool value) noexcept;
 
+  static void SetUseWebFlexBasisBehavior(
+      winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
+      bool value) noexcept;
+
   static void SetAcceptSelfSigned(winrt::Microsoft::ReactNative::ReactInstanceSettings settings, bool value) noexcept;
   static void SetBackHandlerKind(
       winrt::Microsoft::ReactNative::ReactInstanceSettings settings,

package/Microsoft.ReactNative/QuirkSettings.idl

@@ -30,6 +30,13 @@ namespace Microsoft.ReactNative
     DOC_DEFAULT("true")
     static void SetMatchAndroidAndIOSStretchBehavior(ReactInstanceSettings settings, Boolean value);
 
+    DOC_STRING(
+        "There is a chance that cached flex basis values can cause text truncation in some re-layout scenarios. "
+        "Enabling [Yoga](https://github.com/facebook/yoga)'s experimental web flex basis behavior fixes this issue, "
+        "however using it may result in perfomance regressions due to additional layout passes.")
+    DOC_DEFAULT("false")
+    static void SetUseWebFlexBasisBehavior(ReactInstanceSettings settings, Boolean value);
+
     DOC_STRING("Runtime setting allowing Networking (HTTP, WebSocket) connections to skip certificate validation.")
     static void SetAcceptSelfSigned(ReactInstanceSettings settings, Boolean value);
 

package/Microsoft.ReactNative/ReactCoreInjection.cpp

@@ -70,7 +70,7 @@ ReactCoreInjection::PostToUIBatchingQueueProperty() noexcept {
                           .Get(winrt::Microsoft::ReactNative::ReactDispatcherHelper::UIDispatcherProperty())
                           .as<winrt::Microsoft::ReactNative::IReactDispatcher>();
   auto viewHost = rnhost->MakeViewHost(viewOptions.as<ReactViewOptions>()->CreateViewOptions());
-  return winrt::make<ReactViewHost>(*viewHost, uiDispatcher);
+  return winrt::make<ReactViewHost>(host, *viewHost, uiDispatcher);
 }
 
 /*static*/ void ReactCoreInjection::PostToUIBatchingQueue(
@@ -81,9 +81,10 @@ ReactCoreInjection::PostToUIBatchingQueueProperty() noexcept {
 }
 
 ReactViewHost::ReactViewHost(
+    const ReactNative::ReactNativeHost &host,
     Mso::React::IReactViewHost &viewHost,
     const winrt::Microsoft::ReactNative::IReactDispatcher &uiDispatcher)
-    : m_viewHost(&viewHost), m_uiDispatcher(uiDispatcher) {}
+    : m_host(host), m_viewHost(&viewHost), m_uiDispatcher(uiDispatcher) {}
 
 // ReactViewOptions ReactViewHost::Options() noexcept;
 // ReactNative::ReactNativeHost ReactViewHost::ReactHost() noexcept {}
@@ -157,4 +158,8 @@ winrt::Windows::Foundation::IAsyncAction ReactViewHost::DetachViewInstance() noe
   return make<Mso::AsyncActionFutureAdapter>(m_viewHost->DetachViewInstance());
 }
 
+winrt::Microsoft::ReactNative::ReactNativeHost ReactViewHost::ReactNativeHost() noexcept {
+  return m_host;
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactCoreInjection.h

@@ -50,6 +50,7 @@ struct ReactCoreInjection : ReactCoreInjectionT<ReactCoreInjection> {
 
 struct ReactViewHost : public winrt::implements<ReactViewHost, IReactViewHost> {
   ReactViewHost(
+      const winrt::Microsoft::ReactNative::ReactNativeHost &host,
       Mso::React::IReactViewHost &viewHost,
       const winrt::Microsoft::ReactNative::IReactDispatcher &uiDispatcher);
 
@@ -58,8 +59,10 @@ struct ReactViewHost : public winrt::implements<ReactViewHost, IReactViewHost> {
   Windows::Foundation::IAsyncAction UnloadViewInstance() noexcept;
   Windows::Foundation::IAsyncAction AttachViewInstance(IReactViewInstance viewInstance) noexcept;
   Windows::Foundation::IAsyncAction DetachViewInstance() noexcept;
+  winrt::Microsoft::ReactNative::ReactNativeHost ReactNativeHost() noexcept;
 
  private:
+  const ReactNative::ReactNativeHost m_host;
   Mso::CntPtr<Mso::React::IReactViewHost> m_viewHost;
   winrt::Microsoft::ReactNative::IReactDispatcher m_uiDispatcher;
 };
@@ -69,4 +72,4 @@ struct ReactViewHost : public winrt::implements<ReactViewHost, IReactViewHost> {
 namespace winrt::Microsoft::ReactNative::factory_implementation {
 struct ReactCoreInjection : ReactCoreInjectionT<ReactCoreInjection, implementation::ReactCoreInjection> {};
 struct ReactViewOptions : ReactViewOptionsT<ReactViewOptions, implementation::ReactViewOptions> {};
-} // namespace winrt::Microsoft::ReactNative::factory_implementation
+} // namespace winrt::Microsoft::ReactNative::factory_implementation

package/Microsoft.ReactNative/ReactCoreInjection.idl

@@ -63,6 +63,9 @@ DOC_STRING("Settings per each IReactViewHost associated with an IReactHost insta
 
     DOC_STRING("Detaches IReactViewInstance from the IReactViewHost.")
       Windows.Foundation.IAsyncAction DetachViewInstance();
+
+    DOC_STRING("The ReactNativeHost associated with this ReactViewHost.")
+      ReactNativeHost ReactNativeHost { get; };
   }
 
   [experimental]
@@ -89,4 +92,4 @@ DOC_STRING("Settings per each IReactViewHost associated with an IReactHost insta
   }
 
 
-} // namespace Microsoft.ReactNative
+} // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/ReactHost/React.h

@@ -128,9 +128,6 @@ struct ReactViewOptions {
 
   // Initial component properties.
   winrt::Microsoft::ReactNative::JSValueArgWriter InitialProps;
-
-  //! Use Fabric for this ReactView
-  bool UseFabric{false};
 };
 
 struct ReactDevOptions {