react-native-windows 0.78.2 → 0.78.4

package/Directory.Build.props

@@ -20,8 +20,8 @@
     <EnableSourceLink Condition="'$(EnableSourceLink)' == '' AND '$(BuildingInRnwRepo)' == 'true'">true</EnableSourceLink>
     <EnableSourceLink Condition="'$(EnableSourceLink)' == ''">false</EnableSourceLink>
     <!-- When bumping the Folly version, be sure to bump the git hash of that version's commit and build Folly.vcxproj (to update its cgmanifest.json) too. -->
-    <FollyVersion>2023.11.06.00</FollyVersion>
-    <FollyCommitHash>d62707bf4dc8c58bcc317260611b8cbe25c7f444</FollyCommitHash>
+    <FollyVersion>2024.01.01.00</FollyVersion>
+    <FollyCommitHash>234d39a36a43106747d10cc19efada72fd810dd3</FollyCommitHash>
     <!-- When bumping the fmt version, be sure to bump the git hash of that version's commit and build fmt.vcxproj (to update its cgmanifest.json) too. -->
     <FmtVersion>10.1.0</FmtVersion>
     <FmtCommitHash>ca2e3685b160617d3d95fcd9e789c4e06ca88</FmtCommitHash>

package/Folly/TEMP_UntilFollyUpdate/json.cpp

@@ -849,6 +849,10 @@ void escapeStringImpl(
       }
       auto prefix = firstEscapableInWord<EnableExtraAsciiEscapes>(word, opts);
       DCHECK_LE(prefix, avail);
+      // [Windows Sometimes prefix is completely wrong (corrupt?), only in Release, causing a later AV (see issue #14394).
+      // Prefix should always be <= avail, capping it here as a workaround, hoping the assert above eventually catches this in Debug.
+      prefix = std::min(prefix, (size_t)avail);
+      // Windows]
       firstEsc += prefix;
       if (prefix < 8) {
         break;

package/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -38,7 +38,6 @@ struct to_ascii_array {
     return data.data[index];
   }
 };
-
 template <uint64_t Base, typename Alphabet>
 alignas(kIsMobile ? sizeof(size_t) : hardware_constructive_interference_size)
     typename to_ascii_array<Base, Alphabet>::data_type_ const
@@ -94,13 +93,13 @@ extern template to_ascii_table<10, to_ascii_alphabet_upper>::data_type_ const
 extern template to_ascii_table<16, to_ascii_alphabet_upper>::data_type_ const
     to_ascii_table<16, to_ascii_alphabet_upper>::data;
 
-template <uint64_t Base, typename I>
+template <uint64_t Base, typename Int>
 struct to_ascii_powers {
-  static constexpr size_t size_(I v) {
+  static constexpr size_t size_(Int v) {
     return 1 + (v < Base ? 0 : size_(v / Base));
   }
-  static constexpr size_t const size = size_(~I(0));
-  using data_type_ = c_array<I, size>;
+  static constexpr size_t const size = size_(~Int(0));
+  using data_type_ = c_array<Int, size>;
   static constexpr data_type_ data_() {
     data_type_ result{};
     for (size_t i = 0; i < size; ++i) {
@@ -111,12 +110,14 @@ struct to_ascii_powers {
   // @lint-ignore CLANGTIDY
   static data_type_ const data;
 };
-template <uint64_t Base, typename I>
-constexpr size_t const to_ascii_powers<Base, I>::size;
-template <uint64_t Base, typename I>
+#if FOLLY_CPLUSPLUS < 201703L
+template <uint64_t Base, typename Int>
+constexpr size_t const to_ascii_powers<Base, Int>::size;
+#endif
+template <uint64_t Base, typename Int>
 alignas(hardware_constructive_interference_size)
-    typename to_ascii_powers<Base, I>::data_type_ const
-    to_ascii_powers<Base, I>::data = to_ascii_powers<Base, I>::data_();
+    typename to_ascii_powers<Base, Int>::data_type_ const
+    to_ascii_powers<Base, Int>::data = to_ascii_powers<Base, Int>::data_();
 
 extern template to_ascii_powers<8, uint64_t>::data_type_ const
     to_ascii_powers<8, uint64_t>::data;
@@ -151,7 +152,7 @@ template <uint64_t Base>
 FOLLY_ALWAYS_INLINE size_t to_ascii_size_array(uint64_t v) {
   using powers = to_ascii_powers<Base, uint64_t>;
   for (size_t i = 0u; i < powers::size; ++i) {
-    if (FOLLY_LIKELY(v < powers::data.data[i])) {
+    if (FOLLY_UNLIKELY(v < powers::data.data[i])) {
       return i + size_t(i == 0);
     }
   }
@@ -272,6 +273,15 @@ FOLLY_ALWAYS_INLINE size_t to_ascii_with_table(char* out, uint64_t v) {
   return size;
 }
 
+// Assumes that size >= number of digits in v. If >, the result is left-padded
+// with 0s.
+template <uint64_t Base, typename Alphabet>
+FOLLY_ALWAYS_INLINE void to_ascii_with_route(
+    char* outb, size_t size, uint64_t v) {
+  kIsMobile //
+      ? to_ascii_with_array<Base, Alphabet>(outb, size, v)
+      : to_ascii_with_table<Base, Alphabet>(outb, size, v);
+}
 template <uint64_t Base, typename Alphabet>
 FOLLY_ALWAYS_INLINE size_t
 to_ascii_with_route(char* outb, char const* oute, uint64_t v) {
@@ -279,9 +289,7 @@ to_ascii_with_route(char* outb, char const* oute, uint64_t v) {
   if (FOLLY_UNLIKELY(oute < outb || size_t(oute - outb) < size)) {
     return 0;
   }
-  kIsMobile //
-      ? to_ascii_with_array<Base, Alphabet>(outb, size, v)
-      : to_ascii_with_table<Base, Alphabet>(outb, size, v);
+  to_ascii_with_route<Base, Alphabet>(outb, size, v);
   return size;
 }
 template <uint64_t Base, typename Alphabet, size_t N>

package/Folly/TEMP_UntilFollyUpdate/lang/ToAscii.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -61,14 +61,14 @@ using to_ascii_alphabet_upper = to_ascii_alphabet<true>;
 //  In base 10, u64 requires at most 20 bytes, u32 at most 10, u16 at most 5,
 //  and u8 at most 3.
 /*
-template <uint64_t Base, typename I>
+template <uint64_t Base, typename Int>
 FOLLY_INLINE_VARIABLE constexpr size_t to_ascii_size_max =
-  detail::to_ascii_powers<Base, I>::size;
+    detail::to_ascii_powers<Base, Int>::size;
 */
 //  to_ascii_size_max_decimal
 //
 //  An alias to to_ascii_size_max<10>.
-template <typename I>
+template <typename Int>
 FOLLY_INLINE_VARIABLE constexpr size_t to_ascii_size_max_decimal;
 
 template <>
@@ -170,7 +170,7 @@ size_t to_ascii_upper(char (&out)[N], uint64_t v) {
 //
 //  An alias to to_ascii<10, false>.
 //
-//  async-signals-afe
+//  async-signal-safe
 inline size_t to_ascii_decimal(char* outb, char const* oute, uint64_t v) {
   return to_ascii_lower<10>(outb, oute, v);
 }

package/Folly/cgmanifest.json

@@ -6,7 +6,7 @@
                 "Type": "git",
                 "Git": {
                   "RepositoryUrl": "https://github.com/facebook/folly",
-                  "CommitHash": "d62707bf4dc8c58bcc317260611b8cbe25c7f444"
+                  "CommitHash": "234d39a36a43106747d10cc19efada72fd810dd3"
                 }
             },
             "DevelopmentDependency": false

package/Libraries/Modal/Modal.windows.js

@@ -290,8 +290,11 @@ class Modal extends React.Component<Props, State> {
       }
     }
 
+    // [Windows] - apply empty rootViewStyle to AppContainer to prevent modal from always expanding to fill available space
     const innerChildren = __DEV__ ? (
-      <AppContainer rootTag={this.context}>{this.props.children}</AppContainer>
+      <AppContainer rootTag={this.context} rootViewStyle={{}}>
+        {this.props.children}
+      </AppContainer>
     ) : (
       this.props.children
     );

package/Microsoft.ReactNative/Fabric/AbiPortalShadowNode.cpp

@@ -0,0 +1,97 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "AbiPortalShadowNode.h"
+
+#include <Fabric/Composition/ReactCompositionViewComponentBuilder.h>
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/conversions.h>
+
+#include <utility>
+
+namespace Microsoft::ReactNative {
+
+extern const char AbiPortalComponentName[] = "AbiPortal";
+
+facebook::react::Size AbiPortalShadowNode::measureContent(
+    const facebook::react::LayoutContext &layoutContext,
+    const facebook::react::LayoutConstraints &layoutConstraints) const {
+  return {0, 0}; // The portal placeholder node shouldn't take up any space
+}
+
+void AbiPortalShadowNode::layout(facebook::react::LayoutContext layoutContext) {
+  ensureUnsealed();
+  auto layoutMetrics = getLayoutMetrics();
+
+  auto portalOwningShadowNode = ShadowNode::Unshared{};
+
+  if (getChildren().empty()) {
+    return;
+  }
+
+  // A Portal should only have a single child
+  react_native_assert(getChildren().size() == 1);
+
+  const auto &childNode = getChildren()[0];
+
+  auto clonedShadowNode = ShadowNode::Unshared{};
+
+  portalOwningShadowNode = cloneTree(childNode->getFamily(), [&](const ShadowNode &oldShadowNode) {
+    clonedShadowNode = oldShadowNode.clone({});
+    return clonedShadowNode;
+  });
+  auto portalShadowNode = static_cast<AbiPortalShadowNode *>(portalOwningShadowNode.get());
+
+  auto &layoutableShadowNode = dynamic_cast<LayoutableShadowNode &>(*clonedShadowNode);
+
+  auto &state = getStateData();
+
+  facebook::react::LayoutConstraints layoutConstraints;
+  layoutConstraints.layoutDirection = layoutMetrics.layoutDirection;
+
+  if (state.userdata) {
+    // If the portal component set a state of type IPortalStateData,
+    // extract constraint information from it, and use that for layout
+    if (auto portalState = state.userdata.try_as<winrt::Microsoft::ReactNative::Composition::IPortalStateData>()) {
+      auto stateConstraints = portalState.LayoutConstraints();
+
+      layoutConstraints.minimumSize = {stateConstraints.MinimumSize.Width, stateConstraints.MinimumSize.Height};
+      layoutConstraints.maximumSize = {stateConstraints.MaximumSize.Width, stateConstraints.MaximumSize.Height};
+      if (stateConstraints.LayoutDirection == winrt::Microsoft::ReactNative::LayoutDirection::LeftToRight) {
+        layoutConstraints.layoutDirection = facebook::react::LayoutDirection::LeftToRight;
+      } else if (stateConstraints.LayoutDirection == winrt::Microsoft::ReactNative::LayoutDirection::RightToLeft) {
+        layoutConstraints.layoutDirection = facebook::react::LayoutDirection::RightToLeft;
+      }
+    }
+  }
+
+  // Laying out the `ShadowNode` and the subtree starting from it.
+  layoutableShadowNode.layoutTree(layoutContext, layoutConstraints);
+
+  auto childLayoutMetrics = layoutableShadowNode.getLayoutMetrics();
+  childLayoutMetrics.frame.origin = {0, 0};
+  layoutableShadowNode.setLayoutMetrics(childLayoutMetrics);
+
+  // Update the list of children to reflect the changes that we made.
+  this->children_ = static_cast<AbiPortalShadowNode *>(portalOwningShadowNode.get())->children_;
+}
+
+void AbiPortalShadowNode::Builder(winrt::Microsoft::ReactNative::IReactViewComponentBuilder builder) noexcept {
+  m_builder = builder;
+}
+
+winrt::Microsoft::ReactNative::IReactViewComponentBuilder AbiPortalShadowNode::Builder() const noexcept {
+  return m_builder;
+}
+
+void AbiPortalShadowNode::Proxy(winrt::Microsoft::ReactNative::ShadowNode proxy) noexcept {
+  m_proxy = proxy;
+}
+
+winrt::Microsoft::ReactNative::ShadowNode AbiPortalShadowNode::Proxy() const noexcept {
+  return m_proxy;
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Fabric/AbiPortalShadowNode.h

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/components/rnwcore/EventEmitters.h>
+#include <unordered_map>
+#include "AbiShadowNode.h"
+#include "AbiState.h"
+#include "AbiViewProps.h"
+
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutContext.h>
+
+namespace Microsoft::ReactNative {
+
+extern const char AbiPortalComponentName[];
+
+class AbiPortalShadowNode final : public facebook::react::ConcreteViewShadowNode<
+                                      AbiPortalComponentName,
+                                      AbiViewProps,
+                                      facebook::react::ViewEventEmitter,
+                                      Microsoft::ReactNative::AbiStateData> {
+ public:
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+  static facebook::react::ShadowNodeTraits BaseTraits() {
+    auto traits = facebook::react::ShadowNode::BaseTraits();
+    traits.set(facebook::react::ShadowNodeTraits::Trait::FormsStackingContext);
+    traits.set(facebook::react::ShadowNodeTraits::Trait::FormsView);
+    traits.set(facebook::react::ShadowNodeTraits::Trait::RootNodeKind);
+    traits.set(facebook::react::ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(facebook::react::ShadowNodeTraits::Trait::MeasurableYogaNode);
+    return traits;
+  }
+
+  facebook::react::Size measureContent(
+      const facebook::react::LayoutContext &layoutContext,
+      const facebook::react::LayoutConstraints &layoutConstraints) const override;
+  void layout(facebook::react::LayoutContext layoutContext) override;
+
+  void OnClone(const facebook::react::ShadowNode &sourceShadowNode) noexcept;
+  void Builder(winrt::Microsoft::ReactNative::IReactViewComponentBuilder builder) noexcept;
+  winrt::Microsoft::ReactNative::IReactViewComponentBuilder Builder() const noexcept;
+  void Proxy(winrt::Microsoft::ReactNative::ShadowNode handle) noexcept;
+  winrt::Microsoft::ReactNative::ShadowNode Proxy() const noexcept;
+
+ private:
+  winrt::Microsoft::ReactNative::ShadowNode m_proxy{nullptr};
+  winrt::Microsoft::ReactNative::IReactViewComponentBuilder m_builder{nullptr};
+};
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Fabric/AbiViewComponentDescriptor.h

@@ -3,16 +3,22 @@
 
 #pragma once
 
+#include <Fabric/Composition/ReactCompositionViewComponentBuilder.h>
+#include <Fabric/WindowsComponentDescriptorRegistry.h>
+#include <ReactContext.h>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
 #include <react/renderer/core/ComponentDescriptor.h>
+#include "AbiPortalShadowNode.h"
 #include "AbiViewProps.h"
 #include "AbiViewShadowNode.h"
+#include "DynamicReader.h"
 #include "winrt/Microsoft.ReactNative.h"
 
 namespace Microsoft::ReactNative {
 
-class AbiViewComponentDescriptor : public facebook::react::ComponentDescriptor {
-  using ShadowNodeT = AbiViewShadowNode;
+template <typename ShadowNodeT>
+class ConcreteAbiViewComponentDescriptor : public facebook::react::ComponentDescriptor {
+ protected:
   using SharedShadowNodeT = std::shared_ptr<const ShadowNodeT>;
 
  public:
@@ -24,34 +30,142 @@ class AbiViewComponentDescriptor : public facebook::react::ComponentDescriptor {
   using ConcreteState = typename ShadowNodeT::ConcreteState;
   using ConcreteStateData = typename ShadowNodeT::ConcreteState::Data;
 
-  AbiViewComponentDescriptor(facebook::react::ComponentDescriptorParameters const &parameters);
+  ConcreteAbiViewComponentDescriptor(facebook::react::ComponentDescriptorParameters const &parameters)
+      : ComponentDescriptor(parameters) {
+    auto flavor = std::static_pointer_cast<std::string const>(this->flavor_);
+    m_builder = WindowsComponentDescriptorRegistry::FromProperties(
+                    parameters.contextContainer->at<winrt::Microsoft::ReactNative::ReactContext>("MSRN.ReactContext")
+                        .Properties())
+                    ->GetDescriptor(flavor);
+
+    rawPropsParser_.prepare<ConcreteProps>();
+  }
+  facebook::react::ComponentHandle getComponentHandle() const override {
+    return reinterpret_cast<facebook::react::ComponentHandle>(getComponentName());
+  }
+
+  facebook::react::ComponentName getComponentName() const override {
+    return std::static_pointer_cast<std::string const>(this->flavor_)->c_str();
+  }
+
+  facebook::react::ShadowNodeTraits getTraits() const override {
+    auto traits = ShadowNodeT::BaseTraits();
+    if (winrt::get_self<winrt::Microsoft::ReactNative::Composition::ReactCompositionViewComponentBuilder>(m_builder)
+            ->MeasureContentHandler()) {
+      traits.set(facebook::react::ShadowNodeTraits::LeafYogaNode);
+      traits.set(facebook::react::ShadowNodeTraits::MeasurableYogaNode);
+    }
+    return traits;
+  }
 
-  facebook::react::ComponentHandle getComponentHandle() const override;
-  facebook::react::ComponentName getComponentName() const override;
-  facebook::react::ShadowNodeTraits getTraits() const override;
   std::shared_ptr<facebook::react::ShadowNode> createShadowNode(
       const facebook::react::ShadowNodeFragment &fragment,
-      facebook::react::ShadowNodeFamily::Shared const &family) const override;
+      facebook::react::ShadowNodeFamily::Shared const &family) const override {
+    auto shadowNode = std::make_shared<ShadowNodeT>(fragment, family, getTraits());
+    shadowNode->Proxy(winrt::make<winrt::Microsoft::ReactNative::implementation::YogaLayoutableShadowNode>(shadowNode));
+    winrt::get_self<winrt::Microsoft::ReactNative::Composition::ReactCompositionViewComponentBuilder>(m_builder)
+        ->CreateShadowNode(shadowNode->Proxy());
+
+    adopt(*shadowNode);
+    return shadowNode;
+  }
+
   facebook::react::ShadowNode::Unshared cloneShadowNode(
       const facebook::react::ShadowNode &sourceShadowNode,
-      const facebook::react::ShadowNodeFragment &fragment) const override;
+      const facebook::react::ShadowNodeFragment &fragment) const override {
+    auto shadowNode = std::make_shared<ShadowNodeT>(sourceShadowNode, fragment);
+    shadowNode->Proxy(winrt::make<winrt::Microsoft::ReactNative::implementation::YogaLayoutableShadowNode>(shadowNode));
+    winrt::get_self<winrt::Microsoft::ReactNative::Composition::ReactCompositionViewComponentBuilder>(m_builder)
+        ->CloneShadowNode(shadowNode->Proxy(), static_cast<const ShadowNodeT &>(sourceShadowNode).Proxy());
+
+    adopt(*shadowNode);
+    return shadowNode;
+  }
 
   void appendChild(
       const facebook::react::ShadowNode::Shared &parentShadowNode,
-      const facebook::react::ShadowNode::Shared &childShadowNode) const override;
+      const facebook::react::ShadowNode::Shared &childShadowNode) const override {
+    auto concreteParentShadowNode = std::static_pointer_cast<const ShadowNodeT>(parentShadowNode);
+    auto concreteNonConstParentShadowNode = std::const_pointer_cast<ShadowNodeT>(concreteParentShadowNode);
+    concreteNonConstParentShadowNode->appendChild(childShadowNode);
+  }
+
   virtual facebook::react::Props::Shared cloneProps(
       const facebook::react::PropsParserContext &context,
       const facebook::react::Props::Shared &props,
-      facebook::react::RawProps rawProps) const override;
+      facebook::react::RawProps rawProps) const override {
+    // Optimization:
+    // Quite often nodes are constructed with default/empty props: the base
+    // `props` object is `null` (there no base because it's not cloning) and the
+    // `rawProps` is empty. In this case, we can return the default props object
+    // of a concrete type entirely bypassing parsing.
+    if (!props && rawProps.isEmpty()) {
+      return ShadowNodeT::defaultSharedProps();
+    }
+
+    if constexpr (facebook::react::RawPropsFilterable<ShadowNodeT>) {
+      ShadowNodeT::filterRawProps(rawProps);
+    }
+
+    rawProps.parse(rawPropsParser_);
+
+    // Call old-style constructor
+    // auto shadowNodeProps = std::make_shared<ShadowNodeT::Props>(context, rawProps, props);
+    auto shadowNodeProps = std::make_shared<AbiViewProps>(
+        context, props ? static_cast<AbiViewProps const &>(*props) : *ShadowNodeT::defaultSharedProps(), rawProps);
+    auto viewProps =
+        winrt::make<winrt::Microsoft::ReactNative::implementation::ViewProps>(shadowNodeProps, false /*holdRef*/);
+    auto userProps =
+        winrt::get_self<winrt::Microsoft::ReactNative::Composition::ReactCompositionViewComponentBuilder>(m_builder)
+            ->CreateProps(viewProps, props ? static_cast<AbiViewProps const &>(*props).UserProps() : nullptr);
+    shadowNodeProps->SetUserProps(userProps, viewProps);
+
+    const auto &dynamic = static_cast<folly::dynamic>(rawProps);
+    for (const auto &pair : dynamic.items()) {
+      const auto &propName = pair.first.getString();
+      auto hash = RAW_PROPS_KEY_HASH(propName);
+      shadowNodeProps.get()->setProp(context, hash, propName.c_str(), facebook::react::RawValue(pair.second));
+      userProps.SetProp(
+          hash, winrt::to_hstring(propName), winrt::make<winrt::Microsoft::ReactNative::DynamicReader>(pair.second));
+    }
+    return shadowNodeProps;
+  }
+
   virtual facebook::react::State::Shared createInitialState(
       facebook::react::Props::Shared const &props,
-      facebook::react::ShadowNodeFamily::Shared const &family) const override;
+      facebook::react::ShadowNodeFamily::Shared const &family) const override {
+    if (std::is_same<ConcreteStateData, facebook::react::StateData>::value) {
+      // Default case: Returning `null` for nodes that don't use `State`.
+      return nullptr;
+    }
+
+    return std::make_shared<ConcreteState>(
+        std::make_shared<ConcreteStateData const>(
+            ConcreteAbiViewComponentDescriptor<ShadowNodeT>::initialStateData(props, family, *this)),
+        family);
+  }
+
   virtual facebook::react::State::Shared createState(
       facebook::react::ShadowNodeFamily const &family,
-      facebook::react::StateData::Shared const &data) const override;
+      facebook::react::StateData::Shared const &data) const override {
+    if (std::is_same<ConcreteStateData, facebook::react::StateData>::value) {
+      // Default case: Returning `null` for nodes that don't use `State`.
+      return nullptr;
+    }
+
+    react_native_assert(data && "Provided `data` is nullptr.");
+
+    return std::make_shared<ConcreteState const>(
+        std::static_pointer_cast<ConcreteStateData const>(data), *family.getMostRecentState());
+  }
 
   facebook::react::ShadowNodeFamily::Shared createFamily(
-      facebook::react::ShadowNodeFamilyFragment const &fragment) const override;
+      facebook::react::ShadowNodeFamilyFragment const &fragment) const override {
+    auto eventEmitter = std::make_shared<const ConcreteEventEmitter>(
+        std::make_shared<facebook::react::EventTarget>(fragment.instanceHandle, fragment.surfaceId), eventDispatcher_);
+    return std::make_shared<facebook::react::ShadowNodeFamily>(
+        fragment, std::move(eventEmitter), eventDispatcher_, *this);
+  }
 
  protected:
   /*
@@ -66,15 +180,44 @@ class AbiViewComponentDescriptor : public facebook::react::ComponentDescriptor {
    *   - Set `ShadowNode`'s size from state in
    * `ModalHostViewComponentDescriptor`.
    */
-  virtual void adopt(facebook::react::ShadowNode &shadowNode) const;
+  virtual void adopt(facebook::react::ShadowNode &shadowNode) const {
+    react_native_assert(shadowNode.getComponentHandle() == getComponentHandle());
+
+    auto &abiViewShadowNode = static_cast<AbiViewShadowNode &>(shadowNode);
+
+    abiViewShadowNode.Builder(m_builder);
+
+    if (winrt::get_self<winrt::Microsoft::ReactNative::Composition::ReactCompositionViewComponentBuilder>(m_builder)
+            ->MeasureContentHandler()) {
+      abiViewShadowNode.dirtyLayout();
+      abiViewShadowNode.enableMeasurement();
+    }
+  }
 
  private:
   static ConcreteStateData initialStateData(
-      const facebook::react::Props::Shared & /*props*/,
+      const facebook::react::Props::Shared &props,
       const facebook::react::ShadowNodeFamily::Shared & /*family*/,
-      const facebook::react::ComponentDescriptor & /*componentDescriptor*/) noexcept;
+      const facebook::react::ComponentDescriptor &componentDescriptor) noexcept {
+    return {winrt::get_self<winrt::Microsoft::ReactNative::Composition::ReactCompositionViewComponentBuilder>(
+                static_cast<const ConcreteAbiViewComponentDescriptor<ShadowNodeT> &>(componentDescriptor).m_builder)
+                ->InitialStateData(std::static_pointer_cast<AbiViewProps const>(props)->UserProps())};
+    return {};
+  }
 
-  winrt::Microsoft::ReactNative::IReactViewComponentBuilder m_builder;
+  winrt::Microsoft::ReactNative::IReactViewComponentBuilder m_builder{nullptr};
+};
+
+class AbiViewComponentDescriptor : public ConcreteAbiViewComponentDescriptor<AbiViewShadowNode> {
+ public:
+  AbiViewComponentDescriptor(facebook::react::ComponentDescriptorParameters const &parameters)
+      : ConcreteAbiViewComponentDescriptor<AbiViewShadowNode>(parameters) {}
+};
+
+class AbiPortalComponentDescriptor : public ConcreteAbiViewComponentDescriptor<AbiPortalShadowNode> {
+ public:
+  AbiPortalComponentDescriptor(facebook::react::ComponentDescriptorParameters const &parameters)
+      : ConcreteAbiViewComponentDescriptor<AbiPortalShadowNode>(parameters) {}
 };
 
 } // namespace Microsoft::ReactNative