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

package/Microsoft.ReactNative/Fabric/WindowsImageManager.cpp

@@ -0,0 +1,125 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "WindowsImageManager.h"
+
+#include <Utils/ImageUtils.h>
+#include <shcore.h>
+#include <wincodec.h>
+
+extern "C" HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT SDKVersion, IWICImagingFactory **ppIWICImagingFactory);
+
+namespace Microsoft::ReactNative {
+
+WindowsImageManager::WindowsImageManager() {}
+
+winrt::com_ptr<IWICBitmapSource> wicBitmapSourceFromStream(
+    const winrt::Windows::Storage::Streams::IRandomAccessStream &results) noexcept {
+  if (!results) {
+    return nullptr;
+  }
+
+  winrt::com_ptr<IWICImagingFactory> imagingFactory;
+  winrt::check_hresult(WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, imagingFactory.put()));
+
+  winrt::com_ptr<IStream> istream;
+  winrt::check_hresult(
+      CreateStreamOverRandomAccessStream(results.as<IUnknown>().get(), __uuidof(IStream), istream.put_void()));
+
+  winrt::com_ptr<IWICBitmapDecoder> bitmapDecoder;
+  if (imagingFactory->CreateDecoderFromStream(
+          istream.get(), nullptr, WICDecodeMetadataCacheOnDemand, bitmapDecoder.put()) < 0) {
+    return nullptr;
+  }
+
+  winrt::com_ptr<IWICBitmapFrameDecode> decodedFrame;
+  winrt::check_hresult(bitmapDecoder->GetFrame(0, decodedFrame.put()));
+  return decodedFrame;
+}
+
+void generateBitmap(
+    std::weak_ptr<const facebook::react::ImageResponseObserverCoordinator> weakObserverCoordinator,
+    const winrt::Windows::Storage::Streams::IRandomAccessStream &results) noexcept {
+  auto observerCoordinator = weakObserverCoordinator.lock();
+  if (!observerCoordinator) {
+    return;
+  }
+
+  winrt::com_ptr<IWICBitmapSource> decodedFrame = wicBitmapSourceFromStream(results);
+
+  if (!decodedFrame) {
+    observerCoordinator->nativeImageResponseFailed();
+    return;
+  }
+
+  winrt::com_ptr<IWICImagingFactory> imagingFactory;
+  winrt::check_hresult(WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, imagingFactory.put()));
+  winrt::com_ptr<IWICFormatConverter> converter;
+  winrt::check_hresult(imagingFactory->CreateFormatConverter(converter.put()));
+
+  winrt::check_hresult(converter->Initialize(
+      decodedFrame.get(),
+      GUID_WICPixelFormat32bppPBGRA,
+      WICBitmapDitherTypeNone,
+      nullptr,
+      0.0f,
+      WICBitmapPaletteTypeMedianCut));
+
+  winrt::com_ptr<IWICBitmap> wicbmp;
+  winrt::check_hresult(imagingFactory->CreateBitmapFromSource(converter.get(), WICBitmapCacheOnLoad, wicbmp.put()));
+
+  // ImageResponse saves a shared_ptr<void> for its data, so we need to wrap the com_ptr in a shared_ptr...
+  auto sharedwicbmp = std::make_shared<winrt::com_ptr<IWICBitmap>>(wicbmp);
+
+  observerCoordinator->nativeImageResponseComplete(facebook::react::ImageResponse(sharedwicbmp, nullptr /*metadata*/));
+}
+
+facebook::react::ImageRequest WindowsImageManager::requestImage(
+    const facebook::react::ImageSource &imageSource,
+    facebook::react::SurfaceId surfaceId) const {
+  auto imageRequest = facebook::react::ImageRequest(imageSource, nullptr);
+
+  auto weakObserverCoordinator = (std::weak_ptr<const facebook::react::ImageResponseObserverCoordinator>)
+                                     imageRequest.getSharedObserverCoordinator();
+
+  ReactImageSource source;
+  source.uri = imageSource.uri;
+  source.height = imageSource.size.height;
+  source.width = imageSource.size.width;
+  source.sourceType = ImageSourceType::Download;
+
+  auto task = GetImageStreamAsync(source);
+
+  // TODO progress? - Can we register for progress off the download task?
+  // observerCoordinator->nativeImageResponseProgress((float)progress / (float)total);
+
+  task.Completed([weakObserverCoordinator](auto asyncOp, auto status) {
+    auto observerCoordinator = weakObserverCoordinator.lock();
+    if (!observerCoordinator) {
+      return;
+    }
+
+    switch (status) {
+      case winrt::Windows::Foundation::AsyncStatus::Completed: {
+        generateBitmap(weakObserverCoordinator, asyncOp.GetResults());
+        break;
+      }
+      case winrt::Windows::Foundation::AsyncStatus::Canceled: {
+        observerCoordinator->nativeImageResponseFailed();
+        break;
+      }
+      case winrt::Windows::Foundation::AsyncStatus::Error: {
+        observerCoordinator->nativeImageResponseFailed();
+        break;
+      }
+      case winrt::Windows::Foundation::AsyncStatus::Started: {
+      }
+    }
+  });
+
+  return imageRequest;
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Fabric/WindowsImageManager.h

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include <react/renderer/imagemanager/ImageRequest.h>
+
+#include <ReactContext.h>
+
+namespace Microsoft::ReactNative {
+
+struct WindowsImageManager {
+  WindowsImageManager();
+
+  facebook::react::ImageRequest requestImage(
+      const facebook::react::ImageSource &imageSource,
+      facebook::react::SurfaceId surfaceId) const;
+};
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/rncore/States.h

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// RN has some weird include directory redirections..this forwards the include to the right place
+#include <react/components/rnwcore/States.h>

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/rnwcore/States.h

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// RN has some weird include directory redirections..this forwards the include to the right place
+#include <react/components/rnwcore/States.h>

package/Microsoft.ReactNative/Fabric/platform/react/renderer/graphics/Color.cpp

@@ -4,8 +4,7 @@
 #include "Color.h"
 #include <Utils/ValueUtils.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 bool isColorMeaningful(SharedColor const &color) noexcept {
   if (!color) {
@@ -28,11 +27,11 @@ xaml::Media::Brush SharedColor::AsWindowsBrush() const {
 
 SharedColor colorFromComponents(ColorComponents components) {
   float ratio = 255;
-  return SharedColor(ui::ColorHelper::FromArgb(
+  return {ui::ColorHelper::FromArgb(
       (int)round(components.alpha * ratio) & 0xff,
       (int)round(components.red * ratio) & 0xff,
       (int)round(components.green * ratio) & 0xff,
-      (int)round(components.blue * ratio) & 0xff));
+      (int)round(components.blue * ratio) & 0xff)};
 }
 
 ColorComponents colorComponentsFromColor(SharedColor const &sharedColor) {
@@ -57,5 +56,4 @@ SharedColor whiteColor() {
   return color;
 }
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/renderer/graphics/platform/cxx/react/renderer/graphics/Color.h

@@ -12,6 +12,7 @@
 #include <limits>
 
 #include <CppWinRTIncludes.h>
+#include <d2d1_1.h>
 #include <react/renderer/graphics/ColorComponents.h>
 #include <optional>
 
@@ -83,10 +84,26 @@ class SharedColor {
     return m_color != nullptr;
   }
 
+  D2D1::ColorF AsD2DColor() const {
+    return {
+        m_color->m_color.R / 255.0f,
+        m_color->m_color.G / 255.0f,
+        m_color->m_color.B / 255.0f,
+        m_color->m_color.A / 255.0f};
+  }
+
   winrt::Windows::UI::Color AsWindowsColor() const {
     return m_color->m_color;
   }
 
+  COLORREF AsColorRefNoAlpha() const {
+    return RGB(m_color->m_color.R, m_color->m_color.G, m_color->m_color.B);
+  }
+
+  COLORREF AsColorRefWithAlpha() const {
+    return RGB(m_color->m_color.R, m_color->m_color.G, m_color->m_color.B) | (m_color->m_color.A << 24);
+  }
+
 #ifndef CORE_ABI
   xaml::Media::Brush AsWindowsBrush() const;
 #endif

package/Microsoft.ReactNative/INativeUIManager.h

@@ -29,7 +29,6 @@ struct INativeUIManagerHost {
   virtual std::unordered_set<int64_t> &GetAllRootTags() = 0;
   virtual ShadowNode &GetShadowNodeForTag(int64_t tag) = 0;
   virtual ShadowNode *FindShadowNodeForTag(int64_t tag) = 0;
-  virtual ShadowNode *FindParentRootShadowNode(int64_t tag) = 0;
 };
 
 struct INativeUIManager {
@@ -50,6 +49,7 @@ struct INativeUIManager {
   virtual void UpdateView(ShadowNode &shadowNode, winrt::Microsoft::ReactNative::JSValueObject &props) = 0;
   virtual void onBatchComplete() = 0;
   virtual void ensureInBatch() = 0;
+  virtual bool isInBatch() = 0;
   virtual void measure(
       ShadowNode &shadowNode,
       ShadowNode &shadowRoot,

package/Microsoft.ReactNative/IReactPackageBuilder.idl

@@ -26,18 +26,15 @@ namespace Microsoft.ReactNative
     DOC_STRING("Adds a custom native module. See @ReactModuleProvider.")
     void AddModule(String moduleName, ReactModuleProvider moduleProvider);
 
+    DOC_STRING("Adds a custom native module. See @ReactModuleProvider. This will register the"
+    "module as a TurboModule unless the application is running using @ReactInstanceSettings.UseWebDebugger,"
+    "in which case it will revert to a legacy NativeModule.\n"
+    "NOTE: TurboModules using JSI directly will not run correctly while using @ReactInstanceSettings.UseWebDebugger")
+    void AddTurboModule(String moduleName, ReactModuleProvider moduleProvider);
+
 #ifndef CORE_ABI
     DOC_STRING("Adds a custom view manager. See @ReactViewManagerProvider.")
     void AddViewManager(String viewManagerName, ReactViewManagerProvider viewManagerProvider);
 #endif
   }
-
-  [webhosthidden]
-  [experimental]
-  DOC_STRING("Experimental extensions to the @IReactPackageBuilder.")
-  interface IReactPackageBuilderExperimental requires IReactPackageBuilder
-  {
-    DOC_STRING("Adds a custom TurboModule that directly uses the JS Engine API (JSI).")
-    void AddTurboModule(String moduleName, ReactModuleProvider moduleProvider);
-  }
 } // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/IViewManager.idl

@@ -103,4 +103,18 @@ namespace Microsoft.ReactNative
     )
     void OnDropViewInstance(XAML_NAMESPACE.FrameworkElement view);
   };
+
+  [webhosthidden]
+  DOC_STRING(
+    "Enables view managers to receive callback when Yoga layout props are applied. "
+  )
+  interface IViewManagerWithOnLayout {
+    DOC_STRING(
+        "Invoked just before `onLayout` event is emitted for a view. "
+        "Note: this callback is invoked any time the Yoga node returns true from "
+        "YGNodeHasNewLayout. React Native Windows suppresses `onLayout` events "
+        "when the final layout has not changed, so this method may be called "
+        "without a corresponding `onLayout` event in JavaScript.")
+    void OnLayout(XAML_NAMESPACE.FrameworkElement view, Single left, Single top, Single width, Single height);
+  };
 } // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/IViewManagerCore.idl

@@ -19,6 +19,7 @@ namespace Microsoft.ReactNative
     Map,
     Color,
     Function,
+    ImageSource,
   };
 
   [webhosthidden]

package/Microsoft.ReactNative/JsiApi.cpp

@@ -139,6 +139,9 @@ struct RuntimeAccessor : facebook::jsi::Runtime {
 
   using facebook::jsi::Runtime::make;
 
+  using facebook::jsi::Runtime::bigintIsInt64;
+  using facebook::jsi::Runtime::bigintIsUint64;
+  using facebook::jsi::Runtime::bigintToString;
   using facebook::jsi::Runtime::call;
   using facebook::jsi::Runtime::callAsConstructor;
   using facebook::jsi::Runtime::cloneBigInt;
@@ -148,6 +151,9 @@ struct RuntimeAccessor : facebook::jsi::Runtime {
   using facebook::jsi::Runtime::cloneSymbol;
   using facebook::jsi::Runtime::compare;
   using facebook::jsi::Runtime::createArray;
+  using facebook::jsi::Runtime::createArrayBuffer;
+  using facebook::jsi::Runtime::createBigIntFromInt64;
+  using facebook::jsi::Runtime::createBigIntFromUint64;
   using facebook::jsi::Runtime::createFunctionFromHostFunction;
   using facebook::jsi::Runtime::createObject;
   using facebook::jsi::Runtime::createPropNameIDFromAscii;
@@ -159,8 +165,10 @@ struct RuntimeAccessor : facebook::jsi::Runtime {
   using facebook::jsi::Runtime::createWeakObject;
   using facebook::jsi::Runtime::data;
   using facebook::jsi::Runtime::getHostObject;
+  using facebook::jsi::Runtime::getNativeState;
   using facebook::jsi::Runtime::getProperty;
   using facebook::jsi::Runtime::getPropertyNames;
+  using facebook::jsi::Runtime::hasNativeState;
   using facebook::jsi::Runtime::hasProperty;
   using facebook::jsi::Runtime::instanceOf;
   using facebook::jsi::Runtime::isArray;
@@ -171,11 +179,13 @@ struct RuntimeAccessor : facebook::jsi::Runtime {
   using facebook::jsi::Runtime::lockWeakObject;
   using facebook::jsi::Runtime::popScope;
   using facebook::jsi::Runtime::pushScope;
+  using facebook::jsi::Runtime::setNativeState;
   using facebook::jsi::Runtime::setPropertyValue;
   using facebook::jsi::Runtime::setValueAtIndexImpl;
   using facebook::jsi::Runtime::size;
   using facebook::jsi::Runtime::strictEquals;
   using facebook::jsi::Runtime::symbolToString;
+  using facebook::jsi::Runtime::truncate;
   using facebook::jsi::Runtime::utf8;
 
   template <class TDataHolder>
@@ -195,6 +205,22 @@ struct RuntimeAccessor : facebook::jsi::Runtime {
     return *reinterpret_cast<facebook::jsi::BigInt const *>(ptr);
   }
 
+  static uint64_t const &asUint64(facebook::jsi::Runtime::PointerValue *pointerValue) noexcept {
+    return {reinterpret_cast<uint64_t>(pointerValue)};
+  }
+
+  static int64_t const &asInt64(facebook::jsi::Runtime::PointerValue *pointerValue) noexcept {
+    return {reinterpret_cast<int64_t>(pointerValue)};
+  }
+
+  static uint64_t const &AsUint64(facebook::jsi::Runtime::PointerValue *pointerValue) noexcept {
+    return {reinterpret_cast<uint64_t>(pointerValue)};
+  }
+
+  static int64_t const &AsInt64(facebook::jsi::Runtime::PointerValue *pointerValue) noexcept {
+    return {reinterpret_cast<int64_t>(pointerValue)};
+  }
+
   static facebook::jsi::String const &AsString(facebook::jsi::Runtime::PointerValue const **ptr) noexcept {
     return *reinterpret_cast<facebook::jsi::String const *>(ptr);
   }
@@ -838,6 +864,74 @@ JsiObjectRef JsiRuntime::CreateArray(uint32_t size) try {
   throw;
 }
 
+JsiBigIntRef JsiRuntime::CreateBigIntFromInt64(int64_t val) try {
+  return PointerAccessor::MakeJsiBigIntData(m_runtimeAccessor->createBigIntFromInt64(val));
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
+JsiBigIntRef JsiRuntime::CreateBigIntFromUint64(uint64_t val) try {
+  return PointerAccessor::MakeJsiBigIntData(m_runtimeAccessor->createBigIntFromUint64(val));
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
+bool JsiRuntime::BigintIsInt64(JsiBigIntRef obj) try {
+  auto objPtr = RuntimeAccessor::AsPointerValue(obj);
+  return m_runtimeAccessor->bigintIsInt64(RuntimeAccessor::AsBigInt(&objPtr));
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
+bool JsiRuntime::BigintIsUint64(JsiBigIntRef obj) try {
+  auto objPtr = RuntimeAccessor::AsPointerValue(obj);
+  return m_runtimeAccessor->bigintIsUint64(RuntimeAccessor::AsBigInt(&objPtr));
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
+uint64_t JsiRuntime::Truncate(JsiBigIntRef bigInt) try {
+  auto objPtr = RuntimeAccessor::AsPointerValue(bigInt);
+  return m_runtimeAccessor->truncate(RuntimeAccessor::AsBigInt(&objPtr));
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
+JsiStringRef JsiRuntime::BigintToString(JsiBigIntRef bigInt, int val) try {
+  auto objPtr = RuntimeAccessor::AsPointerValue(bigInt);
+  return PointerAccessor::MakeJsiStringData(m_runtimeAccessor->bigintToString(RuntimeAccessor::AsBigInt(&objPtr), val));
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
+bool JsiRuntime::HasNativeState(JsiObjectRef obj) try {
+  auto objPtr = RuntimeAccessor::AsPointerValue(obj);
+  return m_runtimeAccessor->hasNativeState(RuntimeAccessor::AsObject(&objPtr));
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
+JsiObjectRef JsiRuntime::GetNativeState(JsiObjectRef obj) try {
+  // TODO: implement
+  VerifyElseCrash(false);
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
+void JsiRuntime::SetNativeState(JsiObjectRef obj, JsiObjectRef state) try {
+  // TODO: implement
+  VerifyElseCrash(false);
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
+JsiObjectRef JsiRuntime::CreateArrayBuffer(JsiObjectRef buffer) try {
+  auto bufferPtr = RuntimeAccessor::AsPointerValue(buffer);
+  VerifyElseCrash(false);
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
 uint32_t JsiRuntime::GetArraySize(JsiObjectRef arr) try {
   auto arrPtr = RuntimeAccessor::AsPointerValue(arr);
   return static_cast<uint32_t>(m_runtimeAccessor->size(RuntimeAccessor::AsArray(&arrPtr)));

package/Microsoft.ReactNative/JsiApi.h

@@ -99,6 +99,19 @@ struct JsiRuntime : JsiRuntimeT<JsiRuntime> {
   hstring SymbolToString(JsiSymbolRef symbol);
   void SymbolToUtf8(JsiSymbolRef symbol, JsiByteArrayUser const &useUtf8String);
 
+  JsiBigIntRef CreateBigIntFromInt64(int64_t value);
+  JsiBigIntRef CreateBigIntFromUint64(uint64_t value);
+  bool BigintIsInt64(JsiBigIntRef obj);
+  bool BigintIsUint64(JsiBigIntRef obj);
+  uint64_t Truncate(JsiBigIntRef obj);
+  JsiStringRef BigintToString(JsiBigIntRef obj, int radix);
+
+  bool HasNativeState(JsiObjectRef obj);
+  JsiObjectRef GetNativeState(JsiObjectRef obj);
+  void SetNativeState(JsiObjectRef obj, JsiObjectRef state);
+
+  JsiObjectRef CreateArrayBuffer(JsiObjectRef buffer);
+
   JsiStringRef CreateString(hstring const &value);
   JsiStringRef CreateStringFromAscii(array_view<uint8_t const> utf8);
   JsiStringRef CreateStringFromUtf8(array_view<uint8_t const> utf8);

package/Microsoft.ReactNative/JsiApi.idl

@@ -279,6 +279,19 @@ namespace Microsoft.ReactNative
     JsiValueRef CreateValueFromJson(String json);
     JsiValueRef CreateValueFromJsonUtf8(UInt8[] json);
 
+    JsiBigIntRef CreateBigIntFromInt64(Int64 val);
+    JsiBigIntRef CreateBigIntFromUint64(UInt64 val);
+    Boolean BigintIsInt64(JsiBigIntRef bigInt);
+    Boolean BigintIsUint64(JsiBigIntRef bigInt);
+    UInt64 Truncate(JsiBigIntRef bigInt);
+    JsiStringRef BigintToString(JsiBigIntRef bigInt, Int32 val);
+
+    Boolean HasNativeState(JsiObjectRef obj);
+    JsiObjectRef GetNativeState(JsiObjectRef obj);
+    void SetNativeState(JsiObjectRef obj, JsiObjectRef state);
+
+    JsiObjectRef CreateArrayBuffer(JsiObjectRef buffer);  
+
     JsiObjectRef CreateObject();
     JsiObjectRef CreateObjectWithHostObject(IJsiHostObject hostObject);
     IJsiHostObject GetHostObject(JsiObjectRef obj);

package/Microsoft.ReactNative/LayoutService.cpp

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "LayoutService.h"
+#include "LayoutService.g.cpp"
+#include <Modules/NativeUIManager.h>
+#include <Modules/PaperUIManagerModule.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+LayoutService::LayoutService(Mso::CntPtr<Mso::React::IReactContext> &&context) noexcept : m_context(context) {}
+
+/*static*/ winrt::Microsoft::ReactNative::LayoutService LayoutService::FromContext(IReactContext context) {
+  return context.Properties()
+      .Get(LayoutService::LayoutServiceProperty().Handle())
+      .try_as<winrt::Microsoft::ReactNative::LayoutService>();
+}
+
+/*static*/ ReactPropertyId<LayoutService> LayoutService::LayoutServiceProperty() noexcept {
+  static ReactPropertyId<LayoutService> layoutServiceProperty{L"ReactNative.UIManager", L"LayoutService"};
+  return layoutServiceProperty;
+}
+
+void LayoutService::ApplyLayoutForAllNodes() noexcept {
+  if (auto uiManager = ::Microsoft::ReactNative::GetNativeUIManager(*m_context).lock()) {
+    uiManager->DoLayout();
+  }
+}
+
+void LayoutService::ApplyLayout(int64_t reactTag, float width, float height) noexcept {
+  if (auto uiManager = ::Microsoft::ReactNative::GetNativeUIManager(*m_context).lock()) {
+    uiManager->ApplyLayout(reactTag, width, height);
+  }
+}
+
+bool LayoutService::IsInBatch() noexcept {
+  if (auto uiManager = ::Microsoft::ReactNative::GetNativeUIManager(*m_context).lock()) {
+    return uiManager->isInBatch();
+  }
+
+  return false;
+}
+
+void LayoutService::MarkDirty(int64_t reactTag) noexcept {
+  if (auto uiManager = ::Microsoft::ReactNative::GetNativeUIManager(*m_context).lock()) {
+    uiManager->DirtyYogaNode(reactTag);
+  }
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/LayoutService.h

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "LayoutService.g.h"
+#include "INativeUIManager.h"
+#include "ReactHost/React.h"
+#include "ReactPropertyBag.h"
+#include "winrt/Microsoft.ReactNative.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+struct LayoutService : LayoutServiceT<LayoutService> {
+ public:
+  LayoutService(Mso::CntPtr<Mso::React::IReactContext> &&context) noexcept;
+  static winrt::Microsoft::ReactNative::LayoutService FromContext(IReactContext context);
+  static ReactPropertyId<LayoutService> LayoutServiceProperty() noexcept;
+
+  void ApplyLayoutForAllNodes() noexcept;
+  void ApplyLayout(int64_t reactTag, float width, float height) noexcept;
+  bool IsInBatch() noexcept;
+  void MarkDirty(int64_t reactTag) noexcept;
+
+ private:
+  Mso::CntPtr<Mso::React::IReactContext> m_context;
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation
+
+namespace winrt::Microsoft::ReactNative::factory_implementation {
+struct LayoutService : LayoutServiceT<LayoutService, implementation::LayoutService> {};
+} // namespace winrt::Microsoft::ReactNative::factory_implementation

package/Microsoft.ReactNative/LayoutService.idl

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import "IReactContext.idl";
+
+#include "NamespaceRedirect.h"
+#include "DocString.h"
+
+namespace Microsoft.ReactNative
+{
+  [default_interface]
+  [webhosthidden]
+  DOC_STRING("Provides access to Yoga layout functionality.")
+  runtimeclass LayoutService {
+    DOC_STRING("Use this method to get access to the @LayoutService associated with the @IReactContext.")
+    static LayoutService FromContext(IReactContext context);
+
+    DOC_STRING(
+      "Recursively applies layout to all root nodes. This method will trigger "
+      "a Yoga layout operation on roots attached to the React instance and "
+      "apply the layout results to all descendant nodes.")
+    void ApplyLayoutForAllNodes();
+
+    DOC_STRING(
+      "Recursively applies layout from the given React node with the supplied "
+      "size constraints. This method will trigger a Yoga layout operation on the "
+      "given node and its descendants and apply the layout results to these nodes.")
+    void ApplyLayout(Int64 reactTag, Single width, Single height);
+
+    DOC_STRING(
+        "Determines whether the UIManager is currently processing a batch of node updates."
+        "This is useful for optimizing layout and ensuring that applying layout to a particular "
+        "node will not cause tearing in the rendered UI.")
+    Boolean IsInBatch {
+      get;
+    };
+
+    DOC_STRING("Mark a particular React node as dirty for Yoga layout.")
+    void MarkDirty(Int64 reactTag);
+  }
+} // namespace ReactNative