react-native 0.69.0-rc.6 → 0.70.0-rc.0

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

@@ -25,167 +25,328 @@ ViewProps::ViewProps(
     bool shouldSetRawProps)
     : YogaStylableProps(context, sourceProps, rawProps, shouldSetRawProps),
       AccessibilityProps(context, sourceProps, rawProps),
-      opacity(convertRawProp(
-          context,
-          rawProps,
-          "opacity",
-          sourceProps.opacity,
-          (Float)1.0)),
-      foregroundColor(convertRawProp(
-          context,
-          rawProps,
-          "foregroundColor",
-          sourceProps.foregroundColor,
-          {})),
-      backgroundColor(convertRawProp(
-          context,
-          rawProps,
-          "backgroundColor",
-          sourceProps.backgroundColor,
-          {})),
-      borderRadii(convertRawProp(
-          context,
-          rawProps,
-          "border",
-          "Radius",
-          sourceProps.borderRadii,
-          {})),
-      borderColors(convertRawProp(
-          context,
-          rawProps,
-          "border",
-          "Color",
-          sourceProps.borderColors,
-          {})),
-      borderStyles(convertRawProp(
-          context,
-          rawProps,
-          "border",
-          "Style",
-          sourceProps.borderStyles,
-          {})),
-      shadowColor(convertRawProp(
-          context,
-          rawProps,
-          "shadowColor",
-          sourceProps.shadowColor,
-          {})),
-      shadowOffset(convertRawProp(
-          context,
-          rawProps,
-          "shadowOffset",
-          sourceProps.shadowOffset,
-          {})),
-      shadowOpacity(convertRawProp(
-          context,
-          rawProps,
-          "shadowOpacity",
-          sourceProps.shadowOpacity,
-          {})),
-      shadowRadius(convertRawProp(
-          context,
-          rawProps,
-          "shadowRadius",
-          sourceProps.shadowRadius,
-          {})),
-      transform(convertRawProp(
-          context,
-          rawProps,
-          "transform",
-          sourceProps.transform,
-          {})),
-      backfaceVisibility(convertRawProp(
-          context,
-          rawProps,
-          "backfaceVisibility",
-          sourceProps.backfaceVisibility,
-          {})),
-      shouldRasterize(convertRawProp(
-          context,
-          rawProps,
-          "shouldRasterize",
-          sourceProps.shouldRasterize,
-          {})),
+      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(
-          convertRawProp(context, rawProps, "zIndex", sourceProps.zIndex, {})),
-      pointerEvents(convertRawProp(
-          context,
-          rawProps,
-          "pointerEvents",
-          sourceProps.pointerEvents,
-          {})),
-      hitSlop(convertRawProp(
-          context,
-          rawProps,
-          "hitSlop",
-          sourceProps.hitSlop,
-          {})),
-      onLayout(convertRawProp(
-          context,
-          rawProps,
-          "onLayout",
-          sourceProps.onLayout,
-          {})),
-      events(convertRawProp(context, rawProps, sourceProps.events, {})),
-      collapsable(convertRawProp(
-          context,
-          rawProps,
-          "collapsable",
-          sourceProps.collapsable,
-          true)),
-      removeClippedSubviews(convertRawProp(
-          context,
-          rawProps,
-          "removeClippedSubviews",
-          sourceProps.removeClippedSubviews,
-          false))
+          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(convertRawProp(
-          context,
-          rawProps,
-          "elevation",
-          sourceProps.elevation,
-          {})),
-      nativeBackground(convertRawProp(
-          context,
-          rawProps,
-          "nativeBackgroundAndroid",
-          sourceProps.nativeBackground,
-          {})),
-      nativeForeground(convertRawProp(
-          context,
-          rawProps,
-          "nativeForegroundAndroid",
-          sourceProps.nativeForeground,
-          {})),
-      focusable(convertRawProp(
-          context,
-          rawProps,
-          "focusable",
-          sourceProps.focusable,
-          {})),
-      hasTVPreferredFocus(convertRawProp(
-          context,
-          rawProps,
-          "hasTVPreferredFocus",
-          sourceProps.hasTVPreferredFocus,
-          {})),
-      needsOffscreenAlphaCompositing(convertRawProp(
-          context,
-          rawProps,
-          "needsOffscreenAlphaCompositing",
-          sourceProps.needsOffscreenAlphaCompositing,
-          {})),
-      renderToHardwareTextureAndroid(convertRawProp(
-          context,
-          rawProps,
-          "renderToHardwareTextureAndroid",
-          sourceProps.renderToHardwareTextureAndroid,
-          {}))
+      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] = ({                          \
+      bool res = defaultViewEvents[eventType];      \
+      if (value.hasValue()) {                       \
+        fromRawValue(context, value, res);          \
+      }                                             \
+      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) {
@@ -274,8 +435,6 @@ SharedDebugStringConvertibleList ViewProps::getDebugProps() const {
   return AccessibilityProps::getDebugProps() +
       YogaStylableProps::getDebugProps() +
       SharedDebugStringConvertibleList{
-          debugStringConvertibleItem(
-              "zIndex", zIndex, defaultViewProps.zIndex.value_or(0)),
           debugStringConvertibleItem(
               "opacity", opacity, defaultViewProps.opacity),
           debugStringConvertibleItem(
@@ -286,6 +445,8 @@ SharedDebugStringConvertibleList ViewProps::getDebugProps() const {
               "backgroundColor",
               backgroundColor,
               defaultViewProps.backgroundColor),
+          debugStringConvertibleItem(
+              "zIndex", zIndex, defaultViewProps.zIndex.value_or(0)),
       };
 }
 #endif

package/ReactCommon/react/renderer/components/view/ViewProps.h

@@ -35,6 +35,12 @@ class ViewProps : public YogaStylableProps, public AccessibilityProps {
       RawProps const &rawProps,
       bool shouldSetRawProps = true);
 
+  void setProp(
+      const PropsParserContext &context,
+      RawPropsPropNameHash hash,
+      const char *propName,
+      RawValue const &value);
+
 #pragma mark - Props
 
   // Color

package/ReactCommon/react/renderer/components/view/ViewPropsInterpolation.h

@@ -20,9 +20,9 @@ namespace react {
  */
 static inline void interpolateViewProps(
     Float animationProgress,
-    const SharedProps &oldPropsShared,
-    const SharedProps &newPropsShared,
-    SharedProps &interpolatedPropsShared) {
+    const Props::Shared &oldPropsShared,
+    const Props::Shared &newPropsShared,
+    Props::Shared &interpolatedPropsShared) {
   ViewProps const *oldViewProps =
       static_cast<ViewProps const *>(oldPropsShared.get());
   ViewProps const *newViewProps =

package/ReactCommon/react/renderer/components/view/ViewShadowNode.cpp

@@ -70,7 +70,7 @@ void ViewShadowNode::initialize() noexcept {
       (viewProps.zIndex.has_value() &&
        viewProps.yogaStyle.positionType() != YGPositionTypeStatic) ||
       viewProps.yogaStyle.display() == YGDisplayNone ||
-      viewProps.getClipsContentToBounds() ||
+      viewProps.getClipsContentToBounds() || viewProps.events.bits.any() ||
       isColorMeaningful(viewProps.shadowColor) ||
       viewProps.accessibilityElementsHidden ||
       viewProps.accessibilityViewIsModal ||
@@ -84,7 +84,6 @@ void ViewShadowNode::initialize() noexcept {
   bool formsView = formsStackingContext ||
       isColorMeaningful(viewProps.backgroundColor) ||
       isColorMeaningful(viewProps.foregroundColor) ||
-      viewProps.events.bits.any() ||
       !(viewProps.yogaStyle.border() == YGStyle::Edges{}) ||
       !viewProps.testId.empty();
 

package/ReactCommon/react/renderer/components/view/YogaStylableProps.cpp

@@ -25,7 +25,104 @@ YogaStylableProps::YogaStylableProps(
     RawProps const &rawProps,
     bool shouldSetRawProps)
     : Props(context, sourceProps, rawProps, shouldSetRawProps),
-      yogaStyle(convertRawProp(context, rawProps, sourceProps.yogaStyle)){};
+      yogaStyle(
+          Props::enablePropIteratorSetter
+              ? sourceProps.yogaStyle
+              : convertRawProp(context, rawProps, sourceProps.yogaStyle)){};
+
+template <typename T>
+static inline T const getFieldValue(
+    const PropsParserContext &context,
+    RawValue const &value,
+    T const defaultValue) {
+  if (value.hasValue()) {
+    T res;
+    fromRawValue(context, value, res);
+    return res;
+  }
+
+  return defaultValue;
+}
+
+#define REBUILD_FIELD_SWITCH_CASE2(field, fieldName)                     \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldName): {                        \
+    yogaStyle.field() = getFieldValue(context, value, defaults.field()); \
+    return;                                                              \
+  }
+
+#define REBUILD_FIELD_SWITCH_CASE(field) \
+  REBUILD_FIELD_SWITCH_CASE2(field, #field)
+
+#define REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(field, index, fieldName) \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldName): {                     \
+    yogaStyle.field()[index] =                                        \
+        getFieldValue(context, value, defaults.field()[index]);       \
+    return;                                                           \
+  }
+
+#define REBUILD_FIELD_YG_DIMENSION(field, widthStr, heightStr)             \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(field, YGDimensionWidth, widthStr); \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(field, YGDimensionHeight, heightStr);
+
+#define REBUILD_FIELD_YG_EDGES(field, prefix, suffix)                          \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(                                        \
+      field, YGEdgeLeft, prefix "Left" suffix);                                \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(field, YGEdgeTop, prefix "Top" suffix); \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(                                        \
+      field, YGEdgeRight, prefix "Right" suffix);                              \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(                                        \
+      field, YGEdgeBottom, prefix "Bottom" suffix);                            \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(                                        \
+      field, YGEdgeStart, prefix "Start" suffix);                              \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(field, YGEdgeEnd, prefix "End" suffix); \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(                                        \
+      field, YGEdgeHorizontal, prefix "Horizontal" suffix);                    \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(                                        \
+      field, YGEdgeVertical, prefix "Vertical" suffix);                        \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(field, YGEdgeAll, prefix "" suffix);
+
+#define REBUILD_FIELD_YG_EDGES_POSITION()                                 \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(position, YGEdgeLeft, "left");     \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(position, YGEdgeTop, "top");       \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(position, YGEdgeRight, "right");   \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(position, YGEdgeBottom, "bottom"); \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(position, YGEdgeStart, "start");   \
+  REBUILD_YG_FIELD_SWITCH_CASE_INDEXED(position, YGEdgeEnd, "end");
+
+void YogaStylableProps::setProp(
+    const PropsParserContext &context,
+    RawPropsPropNameHash hash,
+    const char *propName,
+    RawValue const &value) {
+  static const auto defaults = YGStyle{};
+
+  Props::setProp(context, hash, propName, value);
+
+  switch (hash) {
+    REBUILD_FIELD_SWITCH_CASE(direction);
+    REBUILD_FIELD_SWITCH_CASE(flexDirection);
+    REBUILD_FIELD_SWITCH_CASE(justifyContent);
+    REBUILD_FIELD_SWITCH_CASE(alignContent);
+    REBUILD_FIELD_SWITCH_CASE(alignItems);
+    REBUILD_FIELD_SWITCH_CASE(alignSelf);
+    REBUILD_FIELD_SWITCH_CASE(flexWrap);
+    REBUILD_FIELD_SWITCH_CASE(overflow);
+    REBUILD_FIELD_SWITCH_CASE(display);
+    REBUILD_FIELD_SWITCH_CASE(flex);
+    REBUILD_FIELD_SWITCH_CASE(flexGrow);
+    REBUILD_FIELD_SWITCH_CASE(flexShrink);
+    REBUILD_FIELD_SWITCH_CASE(flexBasis);
+    REBUILD_FIELD_SWITCH_CASE2(positionType, "position");
+    REBUILD_FIELD_SWITCH_CASE(aspectRatio);
+    REBUILD_FIELD_YG_DIMENSION(dimensions, "width", "height");
+    REBUILD_FIELD_YG_DIMENSION(minDimensions, "minWidth", "minHeight");
+    REBUILD_FIELD_YG_DIMENSION(maxDimensions, "maxWidth", "maxHeight");
+    REBUILD_FIELD_YG_EDGES_POSITION();
+    REBUILD_FIELD_YG_EDGES(margin, "margin", "");
+    REBUILD_FIELD_YG_EDGES(padding, "padding", "");
+    REBUILD_FIELD_YG_EDGES(border, "border", "Width");
+  }
+}
 
 #pragma mark - DebugStringConvertible