@depup/react-native 0.86.2-depup.0 → 0.87.1-depup.0

package/React/Views/RCTShadowView.m

@@ -16,728 +16,6 @@
 #import "UIView+Private.h"
 #import "UIView+React.h"
 
-#ifndef RCT_REMOVE_LEGACY_ARCH
-
-typedef void (^RCTActionBlock)(RCTShadowView *shadowViewSelf, id value);
-typedef void (^RCTResetActionBlock)(RCTShadowView *shadowViewSelf);
-
-typedef NS_ENUM(unsigned int, meta_prop_t) {
-  META_PROP_LEFT,
-  META_PROP_TOP,
-  META_PROP_RIGHT,
-  META_PROP_BOTTOM,
-  META_PROP_START,
-  META_PROP_END,
-  META_PROP_HORIZONTAL,
-  META_PROP_VERTICAL,
-  META_PROP_ALL,
-  META_PROP_COUNT,
-};
-
-@implementation RCTShadowView {
-  NSDictionary *_lastParentProperties;
-  NSMutableArray<RCTShadowView *> *_reactSubviews;
-  BOOL _recomputePadding;
-  BOOL _recomputeMargin;
-  BOOL _recomputeBorder;
-  YGValue _paddingMetaProps[META_PROP_COUNT];
-  YGValue _marginMetaProps[META_PROP_COUNT];
-  YGValue _borderMetaProps[META_PROP_COUNT];
-}
-
-+ (YGConfigRef)yogaConfig
-{
-  static YGConfigRef yogaConfig;
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    yogaConfig = YGConfigNew();
-    YGConfigSetPointScaleFactor(yogaConfig, RCTScreenScale());
-    YGConfigSetErrata(yogaConfig, YGErrataAll);
-  });
-  return yogaConfig;
-}
-
-@synthesize reactTag = _reactTag;
-@synthesize rootTag = _rootTag;
-
-// YogaNode API
-
-#define RCT_SET_YGVALUE(ygvalue, setter, ...)      \
-  switch (ygvalue.unit) {                          \
-    case YGUnitAuto:                               \
-    case YGUnitMaxContent:                         \
-    case YGUnitFitContent:                         \
-    case YGUnitStretch:                            \
-    case YGUnitUndefined:                          \
-      setter(__VA_ARGS__, YGUndefined);            \
-      break;                                       \
-    case YGUnitPoint:                              \
-      setter(__VA_ARGS__, ygvalue.value);          \
-      break;                                       \
-    case YGUnitPercent:                            \
-      setter##Percent(__VA_ARGS__, ygvalue.value); \
-      break;                                       \
-  }
-
-#define RCT_SET_YGVALUE_AUTO(ygvalue, setter, ...) \
-  switch (ygvalue.unit) {                          \
-    case YGUnitAuto:                               \
-      setter##Auto(__VA_ARGS__);                   \
-      break;                                       \
-    case YGUnitUndefined:                          \
-      setter(__VA_ARGS__, YGUndefined);            \
-      break;                                       \
-    case YGUnitPoint:                              \
-      setter(__VA_ARGS__, ygvalue.value);          \
-      break;                                       \
-    case YGUnitPercent:                            \
-      setter##Percent(__VA_ARGS__, ygvalue.value); \
-      break;                                       \
-    case YGUnitMaxContent:                         \
-    case YGUnitFitContent:                         \
-    case YGUnitStretch:                            \
-      break;                                       \
-  }
-
-#define RCT_SET_YGVALUE_AUTO_INTRINSIC(ygvalue, setter, ...) \
-  switch (ygvalue.unit) {                                    \
-    case YGUnitAuto:                                         \
-      setter##Auto(__VA_ARGS__);                             \
-      break;                                                 \
-    case YGUnitMaxContent:                                   \
-      setter##MaxContent(__VA_ARGS__);                       \
-      break;                                                 \
-    case YGUnitFitContent:                                   \
-      setter##FitContent(__VA_ARGS__);                       \
-      break;                                                 \
-    case YGUnitStretch:                                      \
-      setter##Stretch(__VA_ARGS__);                          \
-      break;                                                 \
-    case YGUnitUndefined:                                    \
-      setter(__VA_ARGS__, YGUndefined);                      \
-      break;                                                 \
-    case YGUnitPoint:                                        \
-      setter(__VA_ARGS__, ygvalue.value);                    \
-      break;                                                 \
-    case YGUnitPercent:                                      \
-      setter##Percent(__VA_ARGS__, ygvalue.value);           \
-      break;                                                 \
-  }
-
-static void RCTProcessMetaPropsPadding(const YGValue metaProps[META_PROP_COUNT], YGNodeRef node)
-{
-  if (![[RCTI18nUtil sharedInstance] doLeftAndRightSwapInRTL]) {
-    RCT_SET_YGVALUE(metaProps[META_PROP_START], YGNodeStyleSetPadding, node, YGEdgeStart);
-    RCT_SET_YGVALUE(metaProps[META_PROP_END], YGNodeStyleSetPadding, node, YGEdgeEnd);
-    RCT_SET_YGVALUE(metaProps[META_PROP_LEFT], YGNodeStyleSetPadding, node, YGEdgeLeft);
-    RCT_SET_YGVALUE(metaProps[META_PROP_RIGHT], YGNodeStyleSetPadding, node, YGEdgeRight);
-  } else {
-    YGValue start =
-        metaProps[META_PROP_START].unit == YGUnitUndefined ? metaProps[META_PROP_LEFT] : metaProps[META_PROP_START];
-    YGValue end =
-        metaProps[META_PROP_END].unit == YGUnitUndefined ? metaProps[META_PROP_RIGHT] : metaProps[META_PROP_END];
-    RCT_SET_YGVALUE(start, YGNodeStyleSetPadding, node, YGEdgeStart);
-    RCT_SET_YGVALUE(end, YGNodeStyleSetPadding, node, YGEdgeEnd);
-  }
-  RCT_SET_YGVALUE(metaProps[META_PROP_TOP], YGNodeStyleSetPadding, node, YGEdgeTop);
-  RCT_SET_YGVALUE(metaProps[META_PROP_BOTTOM], YGNodeStyleSetPadding, node, YGEdgeBottom);
-  RCT_SET_YGVALUE(metaProps[META_PROP_HORIZONTAL], YGNodeStyleSetPadding, node, YGEdgeHorizontal);
-  RCT_SET_YGVALUE(metaProps[META_PROP_VERTICAL], YGNodeStyleSetPadding, node, YGEdgeVertical);
-  RCT_SET_YGVALUE(metaProps[META_PROP_ALL], YGNodeStyleSetPadding, node, YGEdgeAll);
-}
-
-static void RCTProcessMetaPropsMargin(const YGValue metaProps[META_PROP_COUNT], YGNodeRef node)
-{
-  if (![[RCTI18nUtil sharedInstance] doLeftAndRightSwapInRTL]) {
-    RCT_SET_YGVALUE_AUTO(metaProps[META_PROP_START], YGNodeStyleSetMargin, node, YGEdgeStart);
-    RCT_SET_YGVALUE_AUTO(metaProps[META_PROP_END], YGNodeStyleSetMargin, node, YGEdgeEnd);
-    RCT_SET_YGVALUE_AUTO(metaProps[META_PROP_LEFT], YGNodeStyleSetMargin, node, YGEdgeLeft);
-    RCT_SET_YGVALUE_AUTO(metaProps[META_PROP_RIGHT], YGNodeStyleSetMargin, node, YGEdgeRight);
-  } else {
-    YGValue start =
-        metaProps[META_PROP_START].unit == YGUnitUndefined ? metaProps[META_PROP_LEFT] : metaProps[META_PROP_START];
-    YGValue end =
-        metaProps[META_PROP_END].unit == YGUnitUndefined ? metaProps[META_PROP_RIGHT] : metaProps[META_PROP_END];
-    RCT_SET_YGVALUE_AUTO(start, YGNodeStyleSetMargin, node, YGEdgeStart);
-    RCT_SET_YGVALUE_AUTO(end, YGNodeStyleSetMargin, node, YGEdgeEnd);
-  }
-  RCT_SET_YGVALUE_AUTO(metaProps[META_PROP_TOP], YGNodeStyleSetMargin, node, YGEdgeTop);
-  RCT_SET_YGVALUE_AUTO(metaProps[META_PROP_BOTTOM], YGNodeStyleSetMargin, node, YGEdgeBottom);
-  RCT_SET_YGVALUE_AUTO(metaProps[META_PROP_HORIZONTAL], YGNodeStyleSetMargin, node, YGEdgeHorizontal);
-  RCT_SET_YGVALUE_AUTO(metaProps[META_PROP_VERTICAL], YGNodeStyleSetMargin, node, YGEdgeVertical);
-  RCT_SET_YGVALUE_AUTO(metaProps[META_PROP_ALL], YGNodeStyleSetMargin, node, YGEdgeAll);
-}
-
-static void RCTProcessMetaPropsBorder(const YGValue metaProps[META_PROP_COUNT], YGNodeRef node)
-{
-  if (![[RCTI18nUtil sharedInstance] doLeftAndRightSwapInRTL]) {
-    YGNodeStyleSetBorder(node, YGEdgeStart, metaProps[META_PROP_START].value);
-    YGNodeStyleSetBorder(node, YGEdgeEnd, metaProps[META_PROP_END].value);
-    YGNodeStyleSetBorder(node, YGEdgeLeft, metaProps[META_PROP_LEFT].value);
-    YGNodeStyleSetBorder(node, YGEdgeRight, metaProps[META_PROP_RIGHT].value);
-  } else {
-    const float start = YGFloatIsUndefined(metaProps[META_PROP_START].value) ? metaProps[META_PROP_LEFT].value
-                                                                             : metaProps[META_PROP_START].value;
-    const float end = YGFloatIsUndefined(metaProps[META_PROP_END].value) ? metaProps[META_PROP_RIGHT].value
-                                                                         : metaProps[META_PROP_END].value;
-    YGNodeStyleSetBorder(node, YGEdgeStart, start);
-    YGNodeStyleSetBorder(node, YGEdgeEnd, end);
-  }
-  YGNodeStyleSetBorder(node, YGEdgeTop, metaProps[META_PROP_TOP].value);
-  YGNodeStyleSetBorder(node, YGEdgeBottom, metaProps[META_PROP_BOTTOM].value);
-  YGNodeStyleSetBorder(node, YGEdgeHorizontal, metaProps[META_PROP_HORIZONTAL].value);
-  YGNodeStyleSetBorder(node, YGEdgeVertical, metaProps[META_PROP_VERTICAL].value);
-  YGNodeStyleSetBorder(node, YGEdgeAll, metaProps[META_PROP_ALL].value);
-}
-
-- (CGRect)measureLayoutRelativeToAncestor:(RCTShadowView *)ancestor
-{
-  CGPoint offset = CGPointZero;
-  RCTShadowView *shadowView = self;
-  while (shadowView && shadowView != ancestor) {
-    offset.x += shadowView.layoutMetrics.frame.origin.x;
-    offset.y += shadowView.layoutMetrics.frame.origin.y;
-    shadowView = shadowView->_superview;
-  }
-  if (ancestor != shadowView) {
-    return CGRectNull;
-  }
-  return (CGRect){offset, self.layoutMetrics.frame.size};
-}
-
-- (BOOL)viewIsDescendantOf:(RCTShadowView *)ancestor
-{
-  RCTShadowView *shadowView = self;
-  while (shadowView && shadowView != ancestor) {
-    shadowView = shadowView->_superview;
-  }
-  return ancestor == shadowView;
-}
-
-- (instancetype)init
-{
-  if (self = [super init]) {
-    for (unsigned int ii = 0; ii < META_PROP_COUNT; ii++) {
-      _paddingMetaProps[ii] = YGValueUndefined;
-      _marginMetaProps[ii] = YGValueUndefined;
-      _borderMetaProps[ii] = YGValueUndefined;
-    }
-
-    _intrinsicContentSize = CGSizeMake(UIViewNoIntrinsicMetric, UIViewNoIntrinsicMetric);
-
-    _newView = YES;
-
-    _reactSubviews = [NSMutableArray array];
-
-    _yogaNode = YGNodeNewWithConfig([[self class] yogaConfig]);
-    YGNodeSetContext(_yogaNode, (__bridge void *)self);
-  }
-  return self;
-}
-
-- (BOOL)isReactRootView
-{
-  return RCTIsReactRootView(self.reactTag);
-}
-
-- (void)dealloc
-{
-  YGNodeFree(_yogaNode);
-}
-
-- (BOOL)canHaveSubviews
-{
-  return YES;
-}
-
-- (BOOL)isYogaLeafNode
-{
-  return NO;
-}
-
-- (void)insertReactSubview:(RCTShadowView *)subview atIndex:(NSInteger)atIndex
-{
-  RCTAssert(self.canHaveSubviews, @"Attempt to insert subview inside leaf view.");
-
-  [_reactSubviews insertObject:subview atIndex:atIndex];
-  if (![self isYogaLeafNode]) {
-    YGNodeInsertChild(_yogaNode, subview.yogaNode, (uint32_t)atIndex);
-  }
-  subview->_superview = self;
-}
-
-- (void)removeReactSubview:(RCTShadowView *)subview
-{
-  subview->_superview = nil;
-  [_reactSubviews removeObject:subview];
-  if (![self isYogaLeafNode]) {
-    YGNodeRemoveChild(_yogaNode, subview.yogaNode);
-  }
-}
-
-- (NSArray<RCTShadowView *> *)reactSubviews
-{
-  return _reactSubviews;
-}
-
-- (RCTShadowView *)reactSuperview
-{
-  return _superview;
-}
-
-#pragma mark - Layout
-
-- (void)layoutWithMinimumSize:(CGSize)minimumSize
-                  maximumSize:(CGSize)maximumSize
-              layoutDirection:(UIUserInterfaceLayoutDirection)layoutDirection
-                layoutContext:(RCTLayoutContext)layoutContext
-{
-  YGNodeRef yogaNode = _yogaNode;
-
-  CGSize oldMinimumSize = (CGSize){RCTCoreGraphicsFloatFromYogaValue(YGNodeStyleGetMinWidth(yogaNode), 0.0),
-                                   RCTCoreGraphicsFloatFromYogaValue(YGNodeStyleGetMinHeight(yogaNode), 0.0)};
-
-  if (!CGSizeEqualToSize(oldMinimumSize, minimumSize)) {
-    YGNodeStyleSetMinWidth(yogaNode, RCTYogaFloatFromCoreGraphicsFloat(minimumSize.width));
-    YGNodeStyleSetMinHeight(yogaNode, RCTYogaFloatFromCoreGraphicsFloat(minimumSize.height));
-  }
-
-  YGNodeCalculateLayout(
-      yogaNode,
-      RCTYogaFloatFromCoreGraphicsFloat(maximumSize.width),
-      RCTYogaFloatFromCoreGraphicsFloat(maximumSize.height),
-      RCTYogaLayoutDirectionFromUIKitLayoutDirection(layoutDirection));
-
-  RCTAssert(!YGNodeIsDirty(yogaNode), @"Attempt to get layout metrics from dirtied Yoga node.");
-
-  if (!YGNodeGetHasNewLayout(yogaNode)) {
-    return;
-  }
-
-  YGNodeSetHasNewLayout(yogaNode, false);
-
-  RCTLayoutMetrics layoutMetrics = RCTLayoutMetricsFromYogaNode(yogaNode);
-
-  layoutContext.absolutePosition.x += layoutMetrics.frame.origin.x;
-  layoutContext.absolutePosition.y += layoutMetrics.frame.origin.y;
-
-  [self layoutWithMetrics:layoutMetrics layoutContext:layoutContext];
-
-  [self layoutSubviewsWithContext:layoutContext];
-}
-
-- (void)layoutWithMetrics:(RCTLayoutMetrics)layoutMetrics layoutContext:(RCTLayoutContext)layoutContext
-{
-  if (!RCTLayoutMetricsEqualToLayoutMetrics(self.layoutMetrics, layoutMetrics)) {
-    self.layoutMetrics = layoutMetrics;
-    [layoutContext.affectedShadowViews addPointer:((__bridge void *)self)];
-  }
-}
-
-- (void)layoutSubviewsWithContext:(RCTLayoutContext)layoutContext
-{
-  RCTLayoutMetrics layoutMetrics = self.layoutMetrics;
-
-  if (layoutMetrics.displayType == RCTDisplayTypeNone) {
-    return;
-  }
-
-  for (RCTShadowView *childShadowView in _reactSubviews) {
-    YGNodeRef childYogaNode = childShadowView.yogaNode;
-
-    RCTAssert(!YGNodeIsDirty(childYogaNode), @"Attempt to get layout metrics from dirtied Yoga node.");
-
-    if (!YGNodeGetHasNewLayout(childYogaNode)) {
-      continue;
-    }
-
-    YGNodeSetHasNewLayout(childYogaNode, false);
-
-    RCTLayoutMetrics childLayoutMetrics = RCTLayoutMetricsFromYogaNode(childYogaNode);
-
-    layoutContext.absolutePosition.x += childLayoutMetrics.frame.origin.x;
-    layoutContext.absolutePosition.y += childLayoutMetrics.frame.origin.y;
-
-    [childShadowView layoutWithMetrics:childLayoutMetrics layoutContext:layoutContext];
-
-    // Recursive call.
-    [childShadowView layoutSubviewsWithContext:layoutContext];
-  }
-}
-
-- (CGSize)sizeThatFitsMinimumSize:(CGSize)minimumSize maximumSize:(CGSize)maximumSize
-{
-  YGNodeRef clonedYogaNode = YGNodeClone(self.yogaNode);
-  YGNodeRef constraintYogaNode = YGNodeNewWithConfig([[self class] yogaConfig]);
-
-  YGNodeInsertChild(constraintYogaNode, clonedYogaNode, 0);
-
-  YGNodeStyleSetMinWidth(constraintYogaNode, RCTYogaFloatFromCoreGraphicsFloat(minimumSize.width));
-  YGNodeStyleSetMinHeight(constraintYogaNode, RCTYogaFloatFromCoreGraphicsFloat(minimumSize.height));
-  YGNodeStyleSetMaxWidth(constraintYogaNode, RCTYogaFloatFromCoreGraphicsFloat(maximumSize.width));
-  YGNodeStyleSetMaxHeight(constraintYogaNode, RCTYogaFloatFromCoreGraphicsFloat(maximumSize.height));
-
-  YGNodeCalculateLayout(
-      constraintYogaNode,
-      YGUndefined,
-      YGUndefined,
-      RCTYogaLayoutDirectionFromUIKitLayoutDirection(self.layoutMetrics.layoutDirection));
-
-  CGSize measuredSize = (CGSize){
-      RCTCoreGraphicsFloatFromYogaFloat(YGNodeLayoutGetWidth(constraintYogaNode)),
-      RCTCoreGraphicsFloatFromYogaFloat(YGNodeLayoutGetHeight(constraintYogaNode)),
-  };
-
-  YGNodeRemoveChild(constraintYogaNode, clonedYogaNode);
-  YGNodeFree(constraintYogaNode);
-  YGNodeFree(clonedYogaNode);
-
-  // `setOwner()` for children unlinked by `YGNodeFree()`
-  int childCount = YGNodeGetChildCount(self.yogaNode);
-  for (int i = 0; i < childCount; i++) {
-    YGNodeRef child = YGNodeGetChild(self.yogaNode, i);
-    YGNodeSwapChild(self.yogaNode, child, i);
-  }
-
-  return measuredSize;
-}
-
-- (NSNumber *)reactTagAtPoint:(CGPoint)point
-{
-  for (RCTShadowView *shadowView in _reactSubviews) {
-    if (CGRectContainsPoint(shadowView.layoutMetrics.frame, point)) {
-      CGPoint relativePoint = point;
-      CGPoint origin = shadowView.layoutMetrics.frame.origin;
-      relativePoint.x -= origin.x;
-      relativePoint.y -= origin.y;
-      return [shadowView reactTagAtPoint:relativePoint];
-    }
-  }
-  return self.reactTag;
-}
-
-- (NSString *)description
-{
-  NSString *description = super.description;
-  description = [[description substringToIndex:description.length - 1]
-      stringByAppendingFormat:@"; viewName: %@; reactTag: %@; frame: %@>",
-                              self.viewName,
-                              self.reactTag,
-                              NSStringFromCGRect(self.layoutMetrics.frame)];
-  return description;
-}
-
-- (void)addRecursiveDescriptionToString:(NSMutableString *)string atLevel:(NSUInteger)level
-{
-  for (NSUInteger i = 0; i < level; i++) {
-    [string appendString:@"  | "];
-  }
-
-  [string appendString:self.description];
-  [string appendString:@"\n"];
-
-  for (RCTShadowView *subview in _reactSubviews) {
-    [subview addRecursiveDescriptionToString:string atLevel:level + 1];
-  }
-}
-
-- (NSString *)recursiveDescription
-{
-  NSMutableString *description = [NSMutableString string];
-  [self addRecursiveDescriptionToString:description atLevel:0];
-  return description;
-}
-
-// Margin
-
-#define RCT_MARGIN_PROPERTY(prop, metaProp)         \
-  -(void)setMargin##prop : (YGValue)value           \
-  {                                                 \
-    _marginMetaProps[META_PROP_##metaProp] = value; \
-    _recomputeMargin = YES;                         \
-  }                                                 \
-  -(YGValue)margin##prop                            \
-  {                                                 \
-    return _marginMetaProps[META_PROP_##metaProp];  \
-  }
-
-RCT_MARGIN_PROPERTY(, ALL)
-RCT_MARGIN_PROPERTY(Vertical, VERTICAL)
-RCT_MARGIN_PROPERTY(Horizontal, HORIZONTAL)
-RCT_MARGIN_PROPERTY(Top, TOP)
-RCT_MARGIN_PROPERTY(Left, LEFT)
-RCT_MARGIN_PROPERTY(Bottom, BOTTOM)
-RCT_MARGIN_PROPERTY(Right, RIGHT)
-RCT_MARGIN_PROPERTY(Start, START)
-RCT_MARGIN_PROPERTY(End, END)
-
-// Padding
-
-#define RCT_PADDING_PROPERTY(prop, metaProp)         \
-  -(void)setPadding##prop : (YGValue)value           \
-  {                                                  \
-    _paddingMetaProps[META_PROP_##metaProp] = value; \
-    _recomputePadding = YES;                         \
-  }                                                  \
-  -(YGValue)padding##prop                            \
-  {                                                  \
-    return _paddingMetaProps[META_PROP_##metaProp];  \
-  }
-
-RCT_PADDING_PROPERTY(, ALL)
-RCT_PADDING_PROPERTY(Vertical, VERTICAL)
-RCT_PADDING_PROPERTY(Horizontal, HORIZONTAL)
-RCT_PADDING_PROPERTY(Top, TOP)
-RCT_PADDING_PROPERTY(Left, LEFT)
-RCT_PADDING_PROPERTY(Bottom, BOTTOM)
-RCT_PADDING_PROPERTY(Right, RIGHT)
-RCT_PADDING_PROPERTY(Start, START)
-RCT_PADDING_PROPERTY(End, END)
-
-// Border
-
-#define RCT_BORDER_PROPERTY(prop, metaProp)               \
-  -(void)setBorder##prop##Width : (float)value            \
-  {                                                       \
-    _borderMetaProps[META_PROP_##metaProp].value = value; \
-    _recomputeBorder = YES;                               \
-  }                                                       \
-  -(float)border##prop##Width                             \
-  {                                                       \
-    return _borderMetaProps[META_PROP_##metaProp].value;  \
-  }
-
-RCT_BORDER_PROPERTY(, ALL)
-RCT_BORDER_PROPERTY(Top, TOP)
-RCT_BORDER_PROPERTY(Left, LEFT)
-RCT_BORDER_PROPERTY(Bottom, BOTTOM)
-RCT_BORDER_PROPERTY(Right, RIGHT)
-RCT_BORDER_PROPERTY(Start, START)
-RCT_BORDER_PROPERTY(End, END)
-
-// Dimensions
-#define RCT_DIMENSION_PROPERTY(setProp, getProp, cssProp)                      \
-  -(void)set##setProp : (YGValue)value                                         \
-  {                                                                            \
-    RCT_SET_YGVALUE_AUTO_INTRINSIC(value, YGNodeStyleSet##cssProp, _yogaNode); \
-  }                                                                            \
-  -(YGValue)getProp                                                            \
-  {                                                                            \
-    return YGNodeStyleGet##cssProp(_yogaNode);                                 \
-  }
-
-#define RCT_MIN_MAX_DIMENSION_PROPERTY(setProp, getProp, cssProp) \
-  -(void)set##setProp : (YGValue)value                            \
-  {                                                               \
-    RCT_SET_YGVALUE(value, YGNodeStyleSet##cssProp, _yogaNode);   \
-  }                                                               \
-  -(YGValue)getProp                                               \
-  {                                                               \
-    return YGNodeStyleGet##cssProp(_yogaNode);                    \
-  }
-
-RCT_DIMENSION_PROPERTY(Width, width, Width)
-RCT_DIMENSION_PROPERTY(Height, height, Height)
-RCT_MIN_MAX_DIMENSION_PROPERTY(MinWidth, minWidth, MinWidth)
-RCT_MIN_MAX_DIMENSION_PROPERTY(MinHeight, minHeight, MinHeight)
-RCT_MIN_MAX_DIMENSION_PROPERTY(MaxWidth, maxWidth, MaxWidth)
-RCT_MIN_MAX_DIMENSION_PROPERTY(MaxHeight, maxHeight, MaxHeight)
-
-// Position
-
-#define RCT_POSITION_PROPERTY(setProp, getProp, edge)                \
-  -(void)set##setProp : (YGValue)value                               \
-  {                                                                  \
-    RCT_SET_YGVALUE(value, YGNodeStyleSetPosition, _yogaNode, edge); \
-  }                                                                  \
-  -(YGValue)getProp                                                  \
-  {                                                                  \
-    return YGNodeStyleGetPosition(_yogaNode, edge);                  \
-  }
-
-RCT_POSITION_PROPERTY(Top, top, YGEdgeTop)
-RCT_POSITION_PROPERTY(Bottom, bottom, YGEdgeBottom)
-RCT_POSITION_PROPERTY(Start, start, YGEdgeStart)
-RCT_POSITION_PROPERTY(End, end, YGEdgeEnd)
-
-- (void)setLeft:(YGValue)value
-{
-  YGEdge edge = [[RCTI18nUtil sharedInstance] doLeftAndRightSwapInRTL] ? YGEdgeStart : YGEdgeLeft;
-  RCT_SET_YGVALUE(value, YGNodeStyleSetPosition, _yogaNode, edge);
-}
-- (YGValue)left
-{
-  YGEdge edge = [[RCTI18nUtil sharedInstance] doLeftAndRightSwapInRTL] ? YGEdgeStart : YGEdgeLeft;
-  return YGNodeStyleGetPosition(_yogaNode, edge);
-}
-
-- (void)setRight:(YGValue)value
-{
-  YGEdge edge = [[RCTI18nUtil sharedInstance] doLeftAndRightSwapInRTL] ? YGEdgeEnd : YGEdgeRight;
-  RCT_SET_YGVALUE(value, YGNodeStyleSetPosition, _yogaNode, edge);
-}
-- (YGValue)right
-{
-  YGEdge edge = [[RCTI18nUtil sharedInstance] doLeftAndRightSwapInRTL] ? YGEdgeEnd : YGEdgeRight;
-  return YGNodeStyleGetPosition(_yogaNode, edge);
-}
-
-// Size
-
-- (CGSize)size
-{
-  YGValue width = YGNodeStyleGetWidth(_yogaNode);
-  YGValue height = YGNodeStyleGetHeight(_yogaNode);
-
-  return CGSizeMake(width.unit == YGUnitPoint ? width.value : NAN, height.unit == YGUnitPoint ? height.value : NAN);
-}
-
-- (void)setSize:(CGSize)size
-{
-  YGNodeStyleSetWidth(_yogaNode, size.width);
-  YGNodeStyleSetHeight(_yogaNode, size.height);
-}
-
-// IntrinsicContentSize
-
-static inline YGSize
-RCTShadowViewMeasure(YGNodeConstRef node, float width, YGMeasureMode widthMode, float height, YGMeasureMode heightMode)
-{
-  RCTShadowView *shadowView = (__bridge RCTShadowView *)YGNodeGetContext(node);
-
-  CGSize intrinsicContentSize = shadowView->_intrinsicContentSize;
-  // Replace `UIViewNoIntrinsicMetric` (which equals `-1`) with zero.
-  intrinsicContentSize.width = MAX(0, intrinsicContentSize.width);
-  intrinsicContentSize.height = MAX(0, intrinsicContentSize.height);
-
-  YGSize result;
-
-  switch (widthMode) {
-    case YGMeasureModeUndefined:
-      result.width = intrinsicContentSize.width;
-      break;
-    case YGMeasureModeExactly:
-      result.width = width;
-      break;
-    case YGMeasureModeAtMost:
-      result.width = MIN(width, intrinsicContentSize.width);
-      break;
-  }
-
-  switch (heightMode) {
-    case YGMeasureModeUndefined:
-      result.height = intrinsicContentSize.height;
-      break;
-    case YGMeasureModeExactly:
-      result.height = height;
-      break;
-    case YGMeasureModeAtMost:
-      result.height = MIN(height, intrinsicContentSize.height);
-      break;
-  }
-
-  return result;
-}
-
-- (void)setIntrinsicContentSize:(CGSize)intrinsicContentSize
-{
-  if (CGSizeEqualToSize(_intrinsicContentSize, intrinsicContentSize)) {
-    return;
-  }
-
-  _intrinsicContentSize = intrinsicContentSize;
-
-  if (CGSizeEqualToSize(_intrinsicContentSize, CGSizeMake(UIViewNoIntrinsicMetric, UIViewNoIntrinsicMetric))) {
-    YGNodeSetMeasureFunc(_yogaNode, NULL);
-  } else {
-    YGNodeSetMeasureFunc(_yogaNode, RCTShadowViewMeasure);
-  }
-
-  YGNodeMarkDirty(_yogaNode);
-}
-
-// Local Data
-
-- (void)setLocalData:(__unused NSObject *)localData
-{
-  // Do nothing by default.
-}
-
-// Flex
-
-- (void)setFlexBasis:(YGValue)value
-{
-  RCT_SET_YGVALUE_AUTO_INTRINSIC(value, YGNodeStyleSetFlexBasis, _yogaNode);
-}
-
-- (YGValue)flexBasis
-{
-  return YGNodeStyleGetFlexBasis(_yogaNode);
-}
-
-#define RCT_GAP_PROPERTY(setProp, getProp, cssProp, gutter)       \
-  -(void)set##setProp : (YGValue)value                            \
-  {                                                               \
-    RCT_SET_YGVALUE(value, YGNodeStyleSetGap, _yogaNode, gutter); \
-  }                                                               \
-  -(YGValue)getProp                                               \
-  {                                                               \
-    return YGNodeStyleGet##cssProp(_yogaNode, gutter);            \
-  }
-
-RCT_GAP_PROPERTY(RowGap, rowGap, Gap, YGGutterRow);
-RCT_GAP_PROPERTY(ColumnGap, columnGap, Gap, YGGutterColumn);
-RCT_GAP_PROPERTY(Gap, gap, Gap, YGGutterAll);
-
-#define RCT_STYLE_PROPERTY(setProp, getProp, cssProp, type) \
-  -(void)set##setProp : (type)value                         \
-  {                                                         \
-    YGNodeStyleSet##cssProp(_yogaNode, value);              \
-  }                                                         \
-  -(type)getProp                                            \
-  {                                                         \
-    return YGNodeStyleGet##cssProp(_yogaNode);              \
-  }
-
-RCT_STYLE_PROPERTY(Flex, flex, Flex, float)
-RCT_STYLE_PROPERTY(FlexGrow, flexGrow, FlexGrow, float)
-RCT_STYLE_PROPERTY(FlexShrink, flexShrink, FlexShrink, float)
-RCT_STYLE_PROPERTY(FlexDirection, flexDirection, FlexDirection, YGFlexDirection)
-RCT_STYLE_PROPERTY(JustifyContent, justifyContent, JustifyContent, YGJustify)
-RCT_STYLE_PROPERTY(AlignSelf, alignSelf, AlignSelf, YGAlign)
-RCT_STYLE_PROPERTY(AlignItems, alignItems, AlignItems, YGAlign)
-RCT_STYLE_PROPERTY(AlignContent, alignContent, AlignContent, YGAlign)
-RCT_STYLE_PROPERTY(Position, position, PositionType, YGPositionType)
-RCT_STYLE_PROPERTY(FlexWrap, flexWrap, FlexWrap, YGWrap)
-RCT_STYLE_PROPERTY(Overflow, overflow, Overflow, YGOverflow)
-RCT_STYLE_PROPERTY(Display, display, Display, YGDisplay)
-RCT_STYLE_PROPERTY(Direction, direction, Direction, YGDirection)
-RCT_STYLE_PROPERTY(AspectRatio, aspectRatio, AspectRatio, float)
-
-- (void)didUpdateReactSubviews
-{
-  // Does nothing by default
-}
-
-- (void)didSetProps:(__unused NSArray<NSString *> *)changedProps
-{
-  if (_recomputePadding) {
-    RCTProcessMetaPropsPadding(_paddingMetaProps, _yogaNode);
-  }
-  if (_recomputeMargin) {
-    RCTProcessMetaPropsMargin(_marginMetaProps, _yogaNode);
-  }
-  if (_recomputeBorder) {
-    RCTProcessMetaPropsBorder(_borderMetaProps, _yogaNode);
-  }
-  _recomputeMargin = NO;
-  _recomputePadding = NO;
-  _recomputeBorder = NO;
-}
-
-@end
-
-#else // RCT_REMOVE_LEGACY_ARCH
 @implementation RCTShadowView
 @synthesize reactTag = _reactTag;
 @synthesize rootTag = _rootTag;
@@ -825,4 +103,3 @@ RCT_STYLE_PROPERTY(AspectRatio, aspectRatio, AspectRatio, float)
 }
 
 @end
-#endif // RCT_REMOVE_LEGACY_ARCH