react-native-windows 0.69.6 → 0.70.0-preview.1

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/ViewProps.cpp

@@ -0,0 +1,455 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "ViewProps.h"
+
+#include <algorithm>
+
+#include <react/renderer/components/view/conversions.h>
+#include <react/renderer/components/view/propsConversions.h>
+#include <react/renderer/core/propsConversions.h>
+#include <react/renderer/debug/debugStringConvertibleUtils.h>
+#include <react/renderer/graphics/conversions.h>
+
+namespace facebook {
+namespace react {
+
+ViewProps::ViewProps(
+    const PropsParserContext &context,
+    ViewProps const &sourceProps,
+    RawProps const &rawProps,
+    bool shouldSetRawProps)
+    : YogaStylableProps(context, sourceProps, rawProps, shouldSetRawProps),
+      AccessibilityProps(context, sourceProps, rawProps),
+      opacity(
+          Props::enablePropIteratorSetter ? sourceProps.opacity
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "opacity",
+                                                sourceProps.opacity,
+                                                (Float)1.0)),
+      foregroundColor(
+          Props::enablePropIteratorSetter ? sourceProps.foregroundColor
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "foregroundColor",
+                                                sourceProps.foregroundColor,
+                                                {})),
+      backgroundColor(
+          Props::enablePropIteratorSetter ? sourceProps.backgroundColor
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "backgroundColor",
+                                                sourceProps.backgroundColor,
+                                                {})),
+      borderRadii(
+          Props::enablePropIteratorSetter ? sourceProps.borderRadii
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "border",
+                                                "Radius",
+                                                sourceProps.borderRadii,
+                                                {})),
+      borderColors(
+          Props::enablePropIteratorSetter ? sourceProps.borderColors
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "border",
+                                                "Color",
+                                                sourceProps.borderColors,
+                                                {})),
+      borderStyles(
+          Props::enablePropIteratorSetter ? sourceProps.borderStyles
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "border",
+                                                "Style",
+                                                sourceProps.borderStyles,
+                                                {})),
+      shadowColor(
+          Props::enablePropIteratorSetter ? sourceProps.shadowColor
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "shadowColor",
+                                                sourceProps.shadowColor,
+                                                {})),
+      shadowOffset(
+          Props::enablePropIteratorSetter ? sourceProps.shadowOffset
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "shadowOffset",
+                                                sourceProps.shadowOffset,
+                                                {})),
+      shadowOpacity(
+          Props::enablePropIteratorSetter ? sourceProps.shadowOpacity
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "shadowOpacity",
+                                                sourceProps.shadowOpacity,
+                                                {})),
+      shadowRadius(
+          Props::enablePropIteratorSetter ? sourceProps.shadowRadius
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "shadowRadius",
+                                                sourceProps.shadowRadius,
+                                                {})),
+      transform(
+          Props::enablePropIteratorSetter ? sourceProps.transform
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "transform",
+                                                sourceProps.transform,
+                                                {})),
+      backfaceVisibility(
+          Props::enablePropIteratorSetter ? sourceProps.backfaceVisibility
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "backfaceVisibility",
+                                                sourceProps.backfaceVisibility,
+                                                {})),
+      shouldRasterize(
+          Props::enablePropIteratorSetter ? sourceProps.shouldRasterize
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "shouldRasterize",
+                                                sourceProps.shouldRasterize,
+                                                {})),
+      zIndex(
+          Props::enablePropIteratorSetter ? sourceProps.zIndex
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "zIndex",
+                                                sourceProps.zIndex,
+                                                {})),
+      pointerEvents(
+          Props::enablePropIteratorSetter ? sourceProps.pointerEvents
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "pointerEvents",
+                                                sourceProps.pointerEvents,
+                                                {})),
+      hitSlop(
+          Props::enablePropIteratorSetter ? sourceProps.hitSlop
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "hitSlop",
+                                                sourceProps.hitSlop,
+                                                {})),
+      onLayout(
+          Props::enablePropIteratorSetter ? sourceProps.onLayout
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "onLayout",
+                                                sourceProps.onLayout,
+                                                {})),
+      events(
+          Props::enablePropIteratorSetter
+              ? sourceProps.events
+              : convertRawProp(context, rawProps, sourceProps.events, {})),
+      collapsable(
+          Props::enablePropIteratorSetter ? sourceProps.collapsable
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "collapsable",
+                                                sourceProps.collapsable,
+                                                true)),
+      removeClippedSubviews(
+          Props::enablePropIteratorSetter
+              ? sourceProps.removeClippedSubviews
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "removeClippedSubviews",
+                    sourceProps.removeClippedSubviews,
+                    false))
+#ifdef ANDROID
+      ,
+      elevation(
+          Props::enablePropIteratorSetter ? sourceProps.elevation
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "elevation",
+                                                sourceProps.elevation,
+                                                {})),
+      nativeBackground(
+          Props::enablePropIteratorSetter ? sourceProps.nativeBackground
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "nativeBackgroundAndroid",
+                                                sourceProps.nativeBackground,
+                                                {})),
+      nativeForeground(
+          Props::enablePropIteratorSetter ? sourceProps.nativeForeground
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "nativeForegroundAndroid",
+                                                sourceProps.nativeForeground,
+                                                {})),
+      focusable(
+          Props::enablePropIteratorSetter ? sourceProps.focusable
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "focusable",
+                                                sourceProps.focusable,
+                                                {})),
+      hasTVPreferredFocus(
+          Props::enablePropIteratorSetter ? sourceProps.hasTVPreferredFocus
+                                          : convertRawProp(
+                                                context,
+                                                rawProps,
+                                                "hasTVPreferredFocus",
+                                                sourceProps.hasTVPreferredFocus,
+                                                {})),
+      needsOffscreenAlphaCompositing(
+          Props::enablePropIteratorSetter
+              ? sourceProps.needsOffscreenAlphaCompositing
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "needsOffscreenAlphaCompositing",
+                    sourceProps.needsOffscreenAlphaCompositing,
+                    {})),
+      renderToHardwareTextureAndroid(
+          Props::enablePropIteratorSetter
+              ? sourceProps.renderToHardwareTextureAndroid
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "renderToHardwareTextureAndroid",
+                    sourceProps.renderToHardwareTextureAndroid,
+                    {}))
+
+#endif
+          {};
+
+#define VIEW_EVENT_CASE(eventType, eventString)     \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(eventString): { \
+    ViewEvents defaultViewEvents{};                 \
+    events[eventType] = [defaultViewEvents, &value, &context]{    \
+        bool res = defaultViewEvents[eventType];    \
+        if (value.hasValue()) {                     \
+            fromRawValue(context, value, res);      \
+        }                                           \
+        return res;                                 \
+    }();                                            \
+    return;                                         \
+  }
+
+void ViewProps::setProp(
+    const PropsParserContext &context,
+    RawPropsPropNameHash hash,
+    const char *propName,
+    RawValue const &value) {
+  // All Props structs setProp methods must always, unconditionally,
+  // call all super::setProp methods, since multiple structs may
+  // reuse the same values.
+  YogaStylableProps::setProp(context, hash, propName, value);
+  AccessibilityProps::setProp(context, hash, propName, value);
+
+  switch (hash) {
+    RAW_SET_PROP_SWITCH_CASE_BASIC(opacity, (Float)1.0);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(foregroundColor, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(backgroundColor, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(shadowColor, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(shadowOffset, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(shadowOpacity, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(shadowRadius, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(transform, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(backfaceVisibility, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(shouldRasterize, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(zIndex, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(pointerEvents, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(hitSlop, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(onLayout, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(collapsable, true);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(removeClippedSubviews, false);
+    // events field
+    VIEW_EVENT_CASE(ViewEvents::Offset::PointerEnter, "onPointerEnter");
+    VIEW_EVENT_CASE(
+        ViewEvents::Offset::PointerEnterCapture, "onPointerEnterCapture");
+    VIEW_EVENT_CASE(ViewEvents::Offset::PointerMove, "onPointerMove");
+    VIEW_EVENT_CASE(
+        ViewEvents::Offset::PointerMoveCapture, "onPointerMoveCapture");
+    VIEW_EVENT_CASE(ViewEvents::Offset::PointerLeave, "onPointerLeave");
+    VIEW_EVENT_CASE(
+        ViewEvents::Offset::PointerLeaveCapture, "onPointerLeaveCapture");
+    VIEW_EVENT_CASE(ViewEvents::Offset::PointerOver, "onPointerOver");
+    VIEW_EVENT_CASE(ViewEvents::Offset::PointerOut, "onPointerOut");
+    VIEW_EVENT_CASE(
+        ViewEvents::Offset::MoveShouldSetResponder, "onMoveShouldSetResponder");
+    VIEW_EVENT_CASE(
+        ViewEvents::Offset::MoveShouldSetResponderCapture,
+        "onMoveShouldSetResponderCapture");
+    VIEW_EVENT_CASE(
+        ViewEvents::Offset::StartShouldSetResponder,
+        "onStartShouldSetResponder");
+    VIEW_EVENT_CASE(
+        ViewEvents::Offset::StartShouldSetResponderCapture,
+        "onStartShouldSetResponderCapture");
+    VIEW_EVENT_CASE(ViewEvents::Offset::ResponderGrant, "onResponderGrant");
+    VIEW_EVENT_CASE(ViewEvents::Offset::ResponderReject, "onResponderReject");
+    VIEW_EVENT_CASE(ViewEvents::Offset::ResponderStart, "onResponderStart");
+    VIEW_EVENT_CASE(ViewEvents::Offset::ResponderEnd, "onResponderEnd");
+    VIEW_EVENT_CASE(ViewEvents::Offset::ResponderRelease, "onResponderRelease");
+    VIEW_EVENT_CASE(ViewEvents::Offset::ResponderMove, "ResponderMove");
+    VIEW_EVENT_CASE(
+        ViewEvents::Offset::ResponderTerminate, "onResponderTerminate");
+    VIEW_EVENT_CASE(
+        ViewEvents::Offset::ResponderTerminationRequest,
+        "onResponderTerminationRequest");
+    VIEW_EVENT_CASE(
+        ViewEvents::Offset::ShouldBlockNativeResponder,
+        "onShouldBlockNativeResponder");
+    VIEW_EVENT_CASE(ViewEvents::Offset::TouchStart, "onTouchStart");
+    VIEW_EVENT_CASE(ViewEvents::Offset::TouchMove, "onTouchMove");
+    VIEW_EVENT_CASE(ViewEvents::Offset::TouchEnd, "onTouchEnd");
+    VIEW_EVENT_CASE(ViewEvents::Offset::TouchCancel, "onTouchCancel");
+#ifdef ANDROID
+    RAW_SET_PROP_SWITCH_CASE_BASIC(elevation, {});
+    RAW_SET_PROP_SWITCH_CASE(nativeBackground, "nativeBackgroundAndroid", {});
+    RAW_SET_PROP_SWITCH_CASE(nativeForeground, "nativeForegroundAndroid", {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(focusable, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(hasTVPreferredFocus, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(needsOffscreenAlphaCompositing, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(renderToHardwareTextureAndroid, false);
+#endif
+    // BorderRadii
+    SET_CASCADED_RECTANGLE_CORNERS(borderRadii, "border", "Radius", value);
+    SET_CASCADED_RECTANGLE_EDGES(borderColors, "border", "Color", value);
+    SET_CASCADED_RECTANGLE_EDGES(borderStyles, "border", "Style", value);
+  }
+}
+
+#pragma mark - Convenience Methods
+
+static BorderRadii ensureNoOverlap(BorderRadii const &radii, Size const &size) {
+  // "Corner curves must not overlap: When the sum of any two adjacent border
+  // radii exceeds the size of the border box, UAs must proportionally reduce
+  // the used values of all border radii until none of them overlap."
+  // Source: https://www.w3.org/TR/css-backgrounds-3/#corner-overlap
+
+  auto insets = EdgeInsets{
+      /* .left = */ radii.topLeft + radii.bottomLeft,
+      /* .top = */ radii.topLeft + radii.topRight,
+      /* .right = */ radii.topRight + radii.bottomRight,
+      /* .bottom = */ radii.bottomLeft + radii.bottomRight,
+  };
+
+  auto insetsScale = EdgeInsets{
+      /* .left = */
+      insets.left > 0 ? std::min((Float)1.0, size.height / insets.left) : 0,
+      /* .top = */
+      insets.top > 0 ? std::min((Float)1.0, size.width / insets.top) : 0,
+      /* .right = */
+      insets.right > 0 ? std::min((Float)1.0, size.height / insets.right) : 0,
+      /* .bottom = */
+      insets.bottom > 0 ? std::min((Float)1.0, size.width / insets.bottom) : 0,
+  };
+
+  return BorderRadii{
+      /* topLeft = */
+      radii.topLeft * std::min(insetsScale.top, insetsScale.left),
+      /* topRight = */
+      radii.topRight * std::min(insetsScale.top, insetsScale.right),
+      /* bottomLeft = */
+      radii.bottomLeft * std::min(insetsScale.bottom, insetsScale.left),
+      /* bottomRight = */
+      radii.bottomRight * std::min(insetsScale.bottom, insetsScale.right),
+  };
+}
+
+BorderMetrics ViewProps::resolveBorderMetrics(
+    LayoutMetrics const &layoutMetrics) const {
+  auto isRTL =
+      bool{layoutMetrics.layoutDirection == LayoutDirection::RightToLeft};
+
+  auto borderWidths = CascadedBorderWidths{
+      /* .left = */ optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeLeft]),
+      /* .top = */ optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeTop]),
+      /* .right = */
+      optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeRight]),
+      /* .bottom = */
+      optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeBottom]),
+      /* .start = */
+      optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeStart]),
+      /* .end = */ optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeEnd]),
+      /* .horizontal = */
+      optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeHorizontal]),
+      /* .vertical = */
+      optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeVertical]),
+      /* .all = */ optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeAll]),
+  };
+
+  return {
+      /* .borderColors = */ borderColors.resolve(isRTL, {}),
+      /* .borderWidths = */ borderWidths.resolve(isRTL, 0),
+      /* .borderRadii = */
+      ensureNoOverlap(borderRadii.resolve(isRTL, 0), layoutMetrics.frame.size),
+      /* .borderStyles = */ borderStyles.resolve(isRTL, BorderStyle::Solid),
+  };
+}
+
+bool ViewProps::getClipsContentToBounds() const {
+  return yogaStyle.overflow() != YGOverflowVisible;
+}
+
+#ifdef ANDROID
+bool ViewProps::getProbablyMoreHorizontalThanVertical_DEPRECATED() const {
+  return yogaStyle.flexDirection() == YGFlexDirectionRow;
+}
+#endif
+
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+SharedDebugStringConvertibleList ViewProps::getDebugProps() const {
+  const auto &defaultViewProps = ViewProps();
+
+  return AccessibilityProps::getDebugProps() +
+      YogaStylableProps::getDebugProps() +
+      SharedDebugStringConvertibleList{
+          debugStringConvertibleItem(
+              "opacity", opacity, defaultViewProps.opacity),
+          debugStringConvertibleItem(
+              "foregroundColor",
+              foregroundColor,
+              defaultViewProps.foregroundColor),
+          debugStringConvertibleItem(
+              "backgroundColor",
+              backgroundColor,
+              defaultViewProps.backgroundColor),
+          debugStringConvertibleItem(
+              "zIndex", zIndex, defaultViewProps.zIndex.value_or(0)),
+      };
+}
+#endif
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/core/ConcreteComponentDescriptor.h

@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <functional>
+#include <memory>
+
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/components/view/ViewPropsInterpolation.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/core/EventDispatcher.h>
+#include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ShadowNodeFragment.h>
+#include <react/renderer/core/State.h>
+#include <react/renderer/graphics/Float.h>
+
+namespace facebook {
+namespace react {
+
+/*
+ * Default template-based implementation of ComponentDescriptor.
+ * Use your `ShadowNode` type as a template argument and override any methods
+ * if necessary.
+ */
+template <typename ShadowNodeT>
+class ConcreteComponentDescriptor : public ComponentDescriptor {
+  static_assert(
+      std::is_base_of<ShadowNode, ShadowNodeT>::value,
+      "ShadowNodeT must be a descendant of ShadowNode");
+
+  using SharedShadowNodeT = std::shared_ptr<const ShadowNodeT>;
+
+ public:
+  using ConcreteShadowNode = ShadowNodeT;
+  using ConcreteProps = typename ShadowNodeT::ConcreteProps;
+  using SharedConcreteProps = typename ShadowNodeT::SharedConcreteProps;
+  using ConcreteEventEmitter = typename ShadowNodeT::ConcreteEventEmitter;
+  using SharedConcreteEventEmitter =
+      typename ShadowNodeT::SharedConcreteEventEmitter;
+  using ConcreteState = typename ShadowNodeT::ConcreteState;
+  using ConcreteStateData = typename ShadowNodeT::ConcreteState::Data;
+
+  ConcreteComponentDescriptor(ComponentDescriptorParameters const &parameters)
+      : ComponentDescriptor(parameters) {
+    rawPropsParser_.prepare<ConcreteProps>();
+  }
+
+  ComponentHandle getComponentHandle() const override {
+    return ShadowNodeT::Handle();
+  }
+
+  ComponentName getComponentName() const override {
+    return ShadowNodeT::Name();
+  }
+
+  ShadowNodeTraits getTraits() const override {
+    return ShadowNodeT::BaseTraits();
+  }
+
+  ShadowNode::Shared createShadowNode(
+      const ShadowNodeFragment &fragment,
+      ShadowNodeFamily::Shared const &family) const override {
+    auto shadowNode =
+        std::make_shared<ShadowNodeT>(fragment, family, getTraits());
+
+    adopt(shadowNode);
+
+    return shadowNode;
+  }
+
+  ShadowNode::Unshared cloneShadowNode(
+      const ShadowNode &sourceShadowNode,
+      const ShadowNodeFragment &fragment) const override {
+    auto shadowNode = std::make_shared<ShadowNodeT>(sourceShadowNode, fragment);
+
+    adopt(shadowNode);
+    return shadowNode;
+  }
+
+  void appendChild(
+      const ShadowNode::Shared &parentShadowNode,
+      const 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 Props::Shared cloneProps(
+      const PropsParserContext &context,
+      const Props::Shared &props,
+      const 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();
+    }
+
+    rawProps.parse(rawPropsParser_, context);
+
+    // Call old-style constructor
+    auto shadowNodeProps = ShadowNodeT::Props(context, rawProps, props);
+
+    // Use the new-style iterator
+    // Note that we just check if `Props` has this flag set, no matter
+    // the type of ShadowNode; it acts as the single global flag.
+    if (Props::enablePropIteratorSetter) {
+      rawProps.iterateOverValues([&](RawPropsPropNameHash hash,
+                                     const char *propName,
+                                     RawValue const &fn) {
+        shadowNodeProps.get()->Props::setProp(context, hash, propName, fn);
+      });
+    }
+
+    return shadowNodeProps;
+  };
+
+  Props::Shared interpolateProps(
+      const PropsParserContext &context,
+      Float animationProgress,
+      const Props::Shared &props,
+      const Props::Shared &newProps) const override {
+#ifdef ANDROID
+    // On Android only, the merged props should have the same RawProps as the
+    // final props struct
+    Props::Shared interpolatedPropsShared =
+        (newProps != nullptr ? cloneProps(context, newProps, newProps->rawProps)
+                             : cloneProps(context, newProps, {}));
+#else
+    Props::Shared interpolatedPropsShared = cloneProps(context, newProps, {});
+#endif
+
+    if (ConcreteShadowNode::BaseTraits().check(
+            ShadowNodeTraits::Trait::ViewKind)) {
+      interpolateViewProps(
+          animationProgress, props, newProps, interpolatedPropsShared);
+    }
+
+    return interpolatedPropsShared;
+  };
+
+  virtual State::Shared createInitialState(
+      ShadowNodeFragment const &fragment,
+      ShadowNodeFamily::Shared const &family) const override {
+    if (std::is_same<ConcreteStateData, 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>(
+            ConcreteShadowNode::initialStateData(
+                fragment, ShadowNodeFamilyFragment::build(*family), *this)),
+        family);
+  }
+
+  virtual State::Shared createState(
+      ShadowNodeFamily const &family,
+      StateData::Shared const &data) const override {
+    if (std::is_same<ConcreteStateData, 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());
+  }
+
+  ShadowNodeFamily::Shared createFamily(
+      ShadowNodeFamilyFragment const &fragment,
+      SharedEventTarget eventTarget) const override {
+    auto eventEmitter = std::make_shared<ConcreteEventEmitter const>(
+        std::move(eventTarget), fragment.tag, eventDispatcher_);
+    return std::make_shared<ShadowNodeFamily>(
+        ShadowNodeFamilyFragment{
+            fragment.tag, fragment.surfaceId, eventEmitter},
+        eventDispatcher_,
+        *this);
+  }
+
+ protected:
+  /*
+   * Called immediatelly after `ShadowNode` is created or cloned.
+   *
+   * Override this method to pass information from custom `ComponentDescriptor`
+   * to new instance of `ShadowNode`.
+   *
+   * Example usages:
+   *   - Inject image manager to `ImageShadowNode` in
+   * `ImageComponentDescriptor`.
+   *   - Set `ShadowNode`'s size from state in
+   * `ModalHostViewComponentDescriptor`.
+   */
+  virtual void adopt(ShadowNode::Unshared const &shadowNode) const {
+    // Default implementation does nothing.
+    react_native_assert(
+        shadowNode->getComponentHandle() == getComponentHandle());
+  }
+};
+
+} // namespace react
+} // namespace facebook