react-native-windows 0.78.3 → 0.78.5

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