react-native-tvos 0.77.0-0rc5 → 0.78.0-0

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactDrawableHelper.kt

@@ -0,0 +1,111 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.views.view
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.RippleDrawable
+import android.util.TypedValue
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.uimanager.ViewProps
+
+/**
+ * Utility class that helps with converting android drawable description used in JS to an actual
+ * instance of [Drawable].
+ */
+public object ReactDrawableHelper {
+
+  private val resolveOutValue = TypedValue()
+
+  @JvmStatic
+  public fun createDrawableFromJSDescription(
+      context: Context,
+      drawableDescriptionDict: ReadableMap
+  ): Drawable? {
+    val type = drawableDescriptionDict.getString("type")
+    if ("ThemeAttrAndroid" == type) {
+      val attr =
+          drawableDescriptionDict.getString("attribute")
+              ?: throw JSApplicationIllegalArgumentException(
+                  "JS description missing 'attribute' field")
+      val attrId = getAttrId(context, attr)
+      if (!context.theme.resolveAttribute(attrId, resolveOutValue, true)) {
+        throw JSApplicationIllegalArgumentException(
+            "Attribute $attr with id $attrId couldn't be resolved into a drawable")
+      }
+      val drawable = getDefaultThemeDrawable(context)
+      return setRadius(drawableDescriptionDict, drawable)
+    } else if ("RippleAndroid" == type) {
+      val rd = getRippleDrawable(context, drawableDescriptionDict)
+      return setRadius(drawableDescriptionDict, rd)
+    } else {
+      throw JSApplicationIllegalArgumentException("Invalid type for android drawable: $type")
+    }
+  }
+
+  @SuppressLint("DiscouragedApi", "InternalInsetResource")
+  private fun getAttrId(context: Context, attr: String): Int =
+      if ("selectableItemBackground" == attr) {
+        android.R.attr.selectableItemBackground
+      } else if ("selectableItemBackgroundBorderless" == attr) {
+        android.R.attr.selectableItemBackgroundBorderless
+      } else {
+        context.resources.getIdentifier(attr, "attr", "android")
+      }
+
+  private fun getDefaultThemeDrawable(context: Context): Drawable? =
+      context.resources.getDrawable(resolveOutValue.resourceId, context.theme)
+
+  private fun getRippleDrawable(
+      context: Context,
+      drawableDescriptionDict: ReadableMap
+  ): RippleDrawable {
+    val color = getColor(context, drawableDescriptionDict)
+    val mask = getMask(drawableDescriptionDict)
+    val colorStateList = ColorStateList(arrayOf(intArrayOf()), intArrayOf(color))
+
+    return RippleDrawable(colorStateList, null, mask)
+  }
+
+  private fun setRadius(drawableDescriptionDict: ReadableMap, drawable: Drawable?): Drawable? {
+    if (drawableDescriptionDict.hasKey("rippleRadius") && drawable is RippleDrawable) {
+      val rippleRadius = drawableDescriptionDict.getDouble("rippleRadius")
+      drawable.radius = PixelUtil.toPixelFromDIP(rippleRadius).toInt()
+    }
+    return drawable
+  }
+
+  private fun getColor(context: Context, drawableDescriptionDict: ReadableMap): Int =
+      if (drawableDescriptionDict.hasKey(ViewProps.COLOR) &&
+          !drawableDescriptionDict.isNull(ViewProps.COLOR)) {
+        drawableDescriptionDict.getInt(ViewProps.COLOR)
+      } else {
+        if (context.theme.resolveAttribute(
+            android.R.attr.colorControlHighlight, resolveOutValue, true)) {
+          context.resources.getColor(resolveOutValue.resourceId, context.theme)
+        } else {
+          throw JSApplicationIllegalArgumentException(
+              "Attribute colorControlHighlight couldn't be resolved into a drawable")
+        }
+      }
+
+  private fun getMask(drawableDescriptionDict: ReadableMap): Drawable? {
+    if (!drawableDescriptionDict.hasKey("borderless") ||
+        drawableDescriptionDict.isNull("borderless") ||
+        !drawableDescriptionDict.getBoolean("borderless")) {
+      return ColorDrawable(Color.WHITE)
+    }
+    return null
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewGroup.java

@@ -110,6 +110,7 @@ public class ReactViewGroup extends ViewGroup
   private boolean trapFocusDown = false;
   private boolean trapFocusLeft = false;
   private boolean trapFocusRight = false;
+  public boolean hasTVPreferredFocus = false;
 
 
   /**
@@ -160,6 +161,7 @@ public class ReactViewGroup extends ViewGroup
   // {@link ViewGroup#getChildCount} so those methods may return views that are not attached.
   // This is risky but allows us to perform a correct cleanup in {@link NativeViewHierarchyManager}.
   private boolean mRemoveClippedSubviews;
+  private volatile boolean mInSubviewClippingLoop;
   private @Nullable View[] mAllChildren;
   private int mAllChildrenCount;
   private @Nullable Rect mClippingRect;
@@ -171,7 +173,7 @@ public class ReactViewGroup extends ViewGroup
   private boolean mNeedsOffscreenAlphaCompositing;
   private @Nullable ViewGroupDrawingOrderHelper mDrawingOrderHelper;
   private float mBackfaceOpacity;
-  private String mBackfaceVisibility;
+  private boolean mBackfaceVisible;
   private @Nullable Set<Integer> mChildrenRemovedWhileTransitioning;
 
   /**
@@ -194,6 +196,7 @@ public class ReactViewGroup extends ViewGroup
     setClipChildren(false);
 
     mRemoveClippedSubviews = false;
+    mInSubviewClippingLoop = false;
     mAllChildren = null;
     mAllChildrenCount = 0;
     mClippingRect = null;
@@ -205,7 +208,7 @@ public class ReactViewGroup extends ViewGroup
     mNeedsOffscreenAlphaCompositing = false;
     mDrawingOrderHelper = null;
     mBackfaceOpacity = 1.f;
-    mBackfaceVisibility = "visible";
+    mBackfaceVisible = true;
     mChildrenRemovedWhileTransitioning = null;
   }
 
@@ -403,6 +406,7 @@ public class ReactViewGroup extends ViewGroup
         View child = getChildAt(i);
         mAllChildren[i] = child;
         child.addOnLayoutChangeListener(mChildrenLayoutChangeListener);
+        setViewClipped(child, false);
       }
       updateClippingRect();
     } else {
@@ -467,11 +471,19 @@ public class ReactViewGroup extends ViewGroup
 
   private void updateClippingToRect(Rect clippingRect) {
     Assertions.assertNotNull(mAllChildren);
+    mInSubviewClippingLoop = true;
     int clippedSoFar = 0;
     for (int i = 0; i < mAllChildrenCount; i++) {
       try {
         updateSubviewClipStatus(clippingRect, i, clippedSoFar);
       } catch (IndexOutOfBoundsException e) {
+        int realClippedSoFar = 0;
+        Set<View> uniqueViews = new HashSet<>();
+        for (int j = 0; j < i; j++) {
+          realClippedSoFar += isViewClipped(mAllChildren[j], null) ? 1 : 0;
+          uniqueViews.add(mAllChildren[j]);
+        }
+
         throw new IllegalStateException(
             "Invalid clipping state. i="
                 + i
@@ -482,13 +494,18 @@ public class ReactViewGroup extends ViewGroup
                 + " allChildrenCount="
                 + mAllChildrenCount
                 + " recycleCount="
-                + mRecycleCount,
+                + mRecycleCount
+                + " realClippedSoFar="
+                + realClippedSoFar
+                + " uniqueViewsCount="
+                + uniqueViews.size(),
             e);
       }
-      if (isViewClipped(mAllChildren[i])) {
+      if (isViewClipped(mAllChildren[i], i)) {
         clippedSoFar++;
       }
     }
+    mInSubviewClippingLoop = false;
   }
 
   private void updateSubviewClipStatus(Rect clippingRect, int idx, int clippedSoFar) {
@@ -507,14 +524,18 @@ public class ReactViewGroup extends ViewGroup
     // it won't be size and located properly.
     Animation animation = child.getAnimation();
     boolean isAnimating = animation != null && !animation.hasEnded();
-    if (!intersects && !isViewClipped(child) && !isAnimating) {
+    if (!intersects && !isViewClipped(child, idx) && !isAnimating) {
+      setViewClipped(child, true);
       recoverFocus(child);
       // We can try saving on invalidate call here as the view that we remove is out of visible area
       // therefore invalidation is not necessary.
       removeViewInLayout(child);
       needUpdateClippingRecursive = true;
-    } else if (intersects && isViewClipped(child)) {
-      addViewInLayout(child, idx - clippedSoFar, sDefaultLayoutParam, true);
+    } else if (intersects && isViewClipped(child, idx)) {
+      int adjustedIdx = idx - clippedSoFar;
+      Assertions.assertCondition(adjustedIdx >= 0);
+      setViewClipped(child, false);
+      addViewInLayout(child, adjustedIdx, sDefaultLayoutParam, true);
       invalidate();
       needUpdateClippingRecursive = true;
     } else if (intersects) {
@@ -545,19 +566,21 @@ public class ReactViewGroup extends ViewGroup
             subview.getLeft(), subview.getTop(), subview.getRight(), subview.getBottom());
 
     // If it was intersecting before, should be attached to the parent
-    boolean oldIntersects = !isViewClipped(subview);
+    boolean oldIntersects = !isViewClipped(subview, null);
 
     if (intersects != oldIntersects) {
+      mInSubviewClippingLoop = true;
       int clippedSoFar = 0;
       for (int i = 0; i < mAllChildrenCount; i++) {
         if (mAllChildren[i] == subview) {
           updateSubviewClipStatus(mClippingRect, i, clippedSoFar);
           break;
         }
-        if (isViewClipped(mAllChildren[i])) {
+        if (isViewClipped(mAllChildren[i], i)) {
           clippedSoFar++;
         }
       }
+      mInSubviewClippingLoop = false;
     }
   }
 
@@ -672,7 +695,7 @@ public class ReactViewGroup extends ViewGroup
   @Override
   public void onViewAdded(View child) {
     UiThreadUtil.assertOnUiThread();
-
+    checkViewClippingTag(child, Boolean.FALSE);
     if (!customDrawOrderDisabled()) {
       getDrawingOrderHelper().handleAddView(child);
       setChildrenDrawingOrderEnabled(getDrawingOrderHelper().shouldEnableCustomDrawingOrder());
@@ -685,7 +708,7 @@ public class ReactViewGroup extends ViewGroup
   @Override
   public void onViewRemoved(View child) {
     UiThreadUtil.assertOnUiThread();
-
+    checkViewClippingTag(child, Boolean.TRUE);
     if (!customDrawOrderDisabled()) {
       if (indexOfChild(child) == -1) {
         return;
@@ -704,6 +727,21 @@ public class ReactViewGroup extends ViewGroup
     super.onViewRemoved(child);
   }
 
+  private void checkViewClippingTag(View child, Boolean expectedTag) {
+    if (mInSubviewClippingLoop) {
+      Object tag = child.getTag(R.id.view_clipped);
+      if (!expectedTag.equals(tag)) {
+        ReactSoftExceptionLogger.logSoftException(
+            ReactSoftExceptionLogger.Categories.RVG_ON_VIEW_REMOVED,
+            new ReactNoCrashSoftException(
+                "View clipping tag mismatch: tag=" + tag + " expected=" + expectedTag));
+      }
+    }
+    if (mRemoveClippedSubviews) {
+      child.setTag(R.id.view_clipped, expectedTag);
+    }
+  }
+
   @Override
   protected int getChildDrawingOrder(int childCount, int index) {
     UiThreadUtil.assertOnUiThread();
@@ -775,19 +813,22 @@ public class ReactViewGroup extends ViewGroup
   /*package*/ void addViewWithSubviewClippingEnabled(
       final View child, int index, ViewGroup.LayoutParams params) {
     Assertions.assertCondition(mRemoveClippedSubviews);
+    setViewClipped(child, true); // the view has not been added, so it is "clipped"
     addInArray(child, index);
 
     // we add view as "clipped" and then run {@link #updateSubviewClipStatus} to conditionally
     // attach it
     Rect clippingRect = Assertions.assertNotNull(mClippingRect);
     View[] childArray = Assertions.assertNotNull(mAllChildren);
+    mInSubviewClippingLoop = true;
     int clippedSoFar = 0;
     for (int i = 0; i < index; i++) {
-      if (isViewClipped(childArray[i])) {
+      if (isViewClipped(childArray[i], i)) {
         clippedSoFar++;
       }
     }
     updateSubviewClipStatus(clippingRect, index, clippedSoFar);
+    mInSubviewClippingLoop = false;
     child.addOnLayoutChangeListener(mChildrenLayoutChangeListener);
 
     if (child instanceof ReactClippingProhibitedView) {
@@ -822,10 +863,10 @@ public class ReactViewGroup extends ViewGroup
     View[] childArray = Assertions.assertNotNull(mAllChildren);
     view.removeOnLayoutChangeListener(mChildrenLayoutChangeListener);
     int index = indexOfChildInAllChildren(view);
-    if (!isViewClipped(childArray[index])) {
+    if (!isViewClipped(childArray[index], index)) {
       int clippedSoFar = 0;
       for (int i = 0; i < index; i++) {
-        if (isViewClipped(childArray[i])) {
+        if (isViewClipped(childArray[i], i)) {
           clippedSoFar++;
         }
       }
@@ -847,9 +888,40 @@ public class ReactViewGroup extends ViewGroup
 
   /**
    * @return {@code true} if the view has been removed from the ViewGroup.
+   * @param index For logging - index of the view in {@code mAllChildren}, or {@code null} to skip
+   *     logging.
    */
-  private boolean isViewClipped(View view) {
-    return view.getParent() == null;
+  private boolean isViewClipped(View view, @Nullable Integer index) {
+    Object tag = view.getTag(R.id.view_clipped);
+    if (tag != null) {
+      return (boolean) tag;
+    }
+    ViewParent parent = view.getParent();
+    boolean transitioning = isChildRemovedWhileTransitioning(view);
+    if (index != null) {
+      ReactSoftExceptionLogger.logSoftException(
+          ReactSoftExceptionLogger.Categories.RVG_IS_VIEW_CLIPPED,
+          new ReactNoCrashSoftException(
+              "View missing clipping tag: index="
+                  + index
+                  + " parentNull="
+                  + (parent == null)
+                  + " parentThis="
+                  + (parent == this)
+                  + " transitioning="
+                  + transitioning));
+    }
+    // fallback - should be transitioning or have no parent if the view was removed
+    if (parent == null || transitioning) {
+      return true;
+    } else {
+      Assertions.assertCondition(parent == this);
+      return false;
+    }
+  }
+
+  private static void setViewClipped(View view, boolean clipped) {
+    view.setTag(R.id.view_clipped, clipped);
   }
 
   private int indexOfChildInAllChildren(View child) {
@@ -1006,6 +1078,7 @@ public class ReactViewGroup extends ViewGroup
 
     BlendMode mixBlendMode = null;
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q
+        && ViewUtil.getUIManagerType(this) == UIManagerType.FABRIC
         && BlendModeHelper.needsIsolatedLayer(this)) {
       mixBlendMode = (BlendMode) child.getTag(R.id.mix_blend_mode);
       if (mixBlendMode != null) {
@@ -1039,14 +1112,12 @@ public class ReactViewGroup extends ViewGroup
   }
 
   public void setBackfaceVisibility(String backfaceVisibility) {
-    mBackfaceVisibility = backfaceVisibility;
+    mBackfaceVisible = "visible".equals(backfaceVisibility);
     setBackfaceVisibilityDependantOpacity();
   }
 
   public void setBackfaceVisibilityDependantOpacity() {
-    boolean isBackfaceVisible = mBackfaceVisibility.equals("visible");
-
-    if (isBackfaceVisible) {
+    if (mBackfaceVisible) {
       setAlpha(mBackfaceOpacity);
       return;
     }

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewManager.kt

@@ -82,6 +82,7 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
     return view
   }
 
+
   @ReactProp(name = "accessible")
   public open fun setAccessible(view: ReactViewGroup, accessible: Boolean) {
     view.isFocusable = accessible
@@ -109,6 +110,17 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
 
   @ReactProp(name = "hasTVPreferredFocus")
   public open fun setTVPreferredFocus(view: ReactViewGroup, hasTVPreferredFocus: Boolean) {
+    /*
+     * React prop functions like this one gets called repeatedly on the New Architecture
+     * no matter the prop has changed or not. Contrary to others, `hasTVPreferredFocus` has
+     * a side effect, calling `requestFocus` function on the view which disrupts the user flow
+     * and should only called once when the property changes to `true.
+     * We keep a special state in the View class and run a comparison here to mitigate
+     * that problem.
+     */
+    if (view.hasTVPreferredFocus == hasTVPreferredFocus) return;
+    view.hasTVPreferredFocus = hasTVPreferredFocus;
+
     if (hasTVPreferredFocus) {
       view.isFocusable = true
       view.isFocusableInTouchMode = true
@@ -259,7 +271,7 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
 
   @ReactProp(name = ViewProps.POINTER_EVENTS)
   public open fun setPointerEvents(view: ReactViewGroup, pointerEventsStr: String?) {
-    view.pointerEvents = PointerEvents.parsePointerEvents(pointerEventsStr)
+    view.setPointerEvents(PointerEvents.parsePointerEvents(pointerEventsStr))
   }
 
   @ReactProp(name = "nativeBackgroundAndroid")
@@ -355,7 +367,7 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
 
   @ReactProp(name = ViewProps.OVERFLOW)
   public open fun setOverflow(view: ReactViewGroup, overflow: String?) {
-    view.overflow = overflow
+    view.setOverflow(overflow)
   }
 
   @ReactProp(name = "backfaceVisibility")

package/ReactAndroid/src/main/java/com/facebook/yoga/YogaNative.java

@@ -74,6 +74,9 @@ public class YogaNative {
   static native void jni_YGNodeStyleSetFlexBasisJNI(long nativePointer, float flexBasis);
   static native void jni_YGNodeStyleSetFlexBasisPercentJNI(long nativePointer, float percent);
   static native void jni_YGNodeStyleSetFlexBasisAutoJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetFlexBasisMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetFlexBasisFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetFlexBasisStretchJNI(long nativePointer);
   static native long jni_YGNodeStyleGetMarginJNI(long nativePointer, int edge);
   static native void jni_YGNodeStyleSetMarginJNI(long nativePointer, int edge, float margin);
   static native void jni_YGNodeStyleSetMarginPercentJNI(long nativePointer, int edge, float percent);
@@ -91,25 +94,43 @@ public class YogaNative {
   static native void jni_YGNodeStyleSetWidthJNI(long nativePointer, float width);
   static native void jni_YGNodeStyleSetWidthPercentJNI(long nativePointer, float percent);
   static native void jni_YGNodeStyleSetWidthAutoJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetWidthMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetWidthFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetWidthStretchJNI(long nativePointer);
   static native long jni_YGNodeStyleGetHeightJNI(long nativePointer);
   static native void jni_YGNodeStyleSetHeightJNI(long nativePointer, float height);
   static native void jni_YGNodeStyleSetHeightPercentJNI(long nativePointer, float percent);
   static native void jni_YGNodeStyleSetHeightAutoJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetHeightMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetHeightFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetHeightStretchJNI(long nativePointer);
   static native long jni_YGNodeStyleGetMinWidthJNI(long nativePointer);
   static native void jni_YGNodeStyleSetMinWidthJNI(long nativePointer, float minWidth);
   static native void jni_YGNodeStyleSetMinWidthPercentJNI(long nativePointer, float percent);
+  static native void jni_YGNodeStyleSetMinWidthMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMinWidthFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMinWidthStretchJNI(long nativePointer);
   static native long jni_YGNodeStyleGetMinHeightJNI(long nativePointer);
   static native void jni_YGNodeStyleSetMinHeightJNI(long nativePointer, float minHeight);
   static native void jni_YGNodeStyleSetMinHeightPercentJNI(long nativePointer, float percent);
+  static native void jni_YGNodeStyleSetMinHeightMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMinHeightFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMinHeightStretchJNI(long nativePointer);
   static native long jni_YGNodeStyleGetMaxWidthJNI(long nativePointer);
   static native void jni_YGNodeStyleSetMaxWidthJNI(long nativePointer, float maxWidth);
   static native void jni_YGNodeStyleSetMaxWidthPercentJNI(long nativePointer, float percent);
+  static native void jni_YGNodeStyleSetMaxWidthMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMaxWidthFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMaxWidthStretchJNI(long nativePointer);
   static native long jni_YGNodeStyleGetMaxHeightJNI(long nativePointer);
   static native void jni_YGNodeStyleSetMaxHeightJNI(long nativePointer, float maxheight);
   static native void jni_YGNodeStyleSetMaxHeightPercentJNI(long nativePointer, float percent);
+  static native void jni_YGNodeStyleSetMaxHeightMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMaxHeightFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMaxHeightStretchJNI(long nativePointer);
   static native float jni_YGNodeStyleGetAspectRatioJNI(long nativePointer);
   static native void jni_YGNodeStyleSetAspectRatioJNI(long nativePointer, float aspectRatio);
-  static native float jni_YGNodeStyleGetGapJNI(long nativePointer, int gutter);
+  static native long jni_YGNodeStyleGetGapJNI(long nativePointer, int gutter);
   static native void jni_YGNodeStyleSetGapJNI(long nativePointer, int gutter, float gapLength);
   static native void jni_YGNodeStyleSetGapPercentJNI(long nativePointer, int gutter, float gapLength);
   static native void jni_YGNodeSetHasMeasureFuncJNI(long nativePointer, boolean hasMeasureFunc);

package/ReactAndroid/src/main/java/com/facebook/yoga/YogaNode.java

@@ -124,6 +124,12 @@ public abstract class YogaNode implements YogaProps {
 
   public abstract void setFlexBasisAuto();
 
+  public abstract void setFlexBasisMaxContent();
+
+  public abstract void setFlexBasisFitContent();
+
+  public abstract void setFlexBasisStretch();
+
   public abstract YogaValue getMargin(YogaEdge edge);
 
   public abstract void setMargin(YogaEdge edge, float margin);
@@ -158,6 +164,12 @@ public abstract class YogaNode implements YogaProps {
 
   public abstract void setWidthAuto();
 
+  public abstract void setWidthMaxContent();
+
+  public abstract void setWidthFitContent();
+
+  public abstract void setWidthStretch();
+
   public abstract YogaValue getHeight();
 
   public abstract void setHeight(float height);
@@ -166,35 +178,65 @@ public abstract class YogaNode implements YogaProps {
 
   public abstract void setHeightAuto();
 
+  public abstract void setHeightMaxContent();
+
+  public abstract void setHeightFitContent();
+
+  public abstract void setHeightStretch();
+
   public abstract YogaValue getMinWidth();
 
   public abstract void setMinWidth(float minWidth);
 
   public abstract void setMinWidthPercent(float percent);
 
+  public abstract void setMinWidthMaxContent();
+
+  public abstract void setMinWidthFitContent();
+
+  public abstract void setMinWidthStretch();
+
   public abstract YogaValue getMinHeight();
 
   public abstract void setMinHeight(float minHeight);
 
   public abstract void setMinHeightPercent(float percent);
 
+  public abstract void setMinHeightMaxContent();
+
+  public abstract void setMinHeightFitContent();
+
+  public abstract void setMinHeightStretch();
+
   public abstract YogaValue getMaxWidth();
 
   public abstract void setMaxWidth(float maxWidth);
 
   public abstract void setMaxWidthPercent(float percent);
 
+  public abstract void setMaxWidthMaxContent();
+
+  public abstract void setMaxWidthFitContent();
+
+  public abstract void setMaxWidthStretch();
+
   public abstract YogaValue getMaxHeight();
 
   public abstract void setMaxHeight(float maxheight);
 
   public abstract void setMaxHeightPercent(float percent);
 
+  public abstract void setMaxHeightMaxContent();
+
+  public abstract void setMaxHeightFitContent();
+
+  public abstract void setMaxHeightStretch();
+
   public abstract float getAspectRatio();
 
   public abstract void setAspectRatio(float aspectRatio);
 
-  public abstract float getGap(YogaGutter gutter);
+  public abstract YogaValue getGap(YogaGutter gutter);
 
   public abstract void setGap(YogaGutter gutter, float gapLength);