react-native-tvos 0.85.2-0 → 0.86.0-0rc2

package/ReactCommon/yoga/yoga/YGNodeStyle.cpp

@@ -8,6 +8,7 @@
 #include <yoga/Yoga.h>
 #include <yoga/debug/AssertFatal.h>
 #include <yoga/node/Node.h>
+#include <yoga/style/GridTrack.h>
 
 using namespace facebook;
 using namespace facebook::yoga;
@@ -74,6 +75,24 @@ YGJustify YGNodeStyleGetJustifyContent(const YGNodeConstRef node) {
   return unscopedEnum(resolveRef(node)->style().justifyContent());
 }
 
+void YGNodeStyleSetJustifyItems(YGNodeRef node, const YGJustify justifyItems) {
+  updateStyle<&Style::justifyItems, &Style::setJustifyItems>(
+      node, scopedEnum(justifyItems));
+}
+
+YGJustify YGNodeStyleGetJustifyItems(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().justifyItems());
+}
+
+void YGNodeStyleSetJustifySelf(YGNodeRef node, const YGJustify justifySelf) {
+  updateStyle<&Style::justifySelf, &Style::setJustifySelf>(
+      node, scopedEnum(justifySelf));
+}
+
+YGJustify YGNodeStyleGetJustifySelf(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().justifySelf());
+}
+
 void YGNodeStyleSetAlignContent(
     const YGNodeRef node,
     const YGAlign alignContent) {
@@ -503,3 +522,253 @@ void YGNodeStyleSetMaxHeightStretch(const YGNodeRef node) {
 YGValue YGNodeStyleGetMaxHeight(const YGNodeConstRef node) {
   return (YGValue)resolveRef(node)->style().maxDimension(Dimension::Height);
 }
+
+// Grid Item Placement Properties
+
+void YGNodeStyleSetGridColumnStart(YGNodeRef node, int32_t gridColumnStart) {
+  updateStyle<&Style::gridColumnStart, &Style::setGridColumnStart>(
+      node, GridLine::fromInteger(gridColumnStart));
+}
+
+void YGNodeStyleSetGridColumnStartAuto(YGNodeRef node) {
+  updateStyle<&Style::gridColumnStart, &Style::setGridColumnStart>(
+      node, GridLine::auto_());
+}
+
+void YGNodeStyleSetGridColumnStartSpan(YGNodeRef node, int32_t span) {
+  updateStyle<&Style::gridColumnStart, &Style::setGridColumnStart>(
+      node, GridLine::span(span));
+}
+
+int32_t YGNodeStyleGetGridColumnStart(YGNodeConstRef node) {
+  const auto& gridLine = resolveRef(node)->style().gridColumnStart();
+  return gridLine.isInteger() ? gridLine.integer : 0;
+}
+
+void YGNodeStyleSetGridColumnEnd(YGNodeRef node, int32_t gridColumnEnd) {
+  updateStyle<&Style::gridColumnEnd, &Style::setGridColumnEnd>(
+      node, GridLine::fromInteger(gridColumnEnd));
+}
+
+void YGNodeStyleSetGridColumnEndAuto(YGNodeRef node) {
+  updateStyle<&Style::gridColumnEnd, &Style::setGridColumnEnd>(
+      node, GridLine::auto_());
+}
+
+void YGNodeStyleSetGridColumnEndSpan(YGNodeRef node, int32_t span) {
+  updateStyle<&Style::gridColumnEnd, &Style::setGridColumnEnd>(
+      node, GridLine::span(span));
+}
+
+int32_t YGNodeStyleGetGridColumnEnd(YGNodeConstRef node) {
+  const auto& gridLine = resolveRef(node)->style().gridColumnEnd();
+  return gridLine.isInteger() ? gridLine.integer : 0;
+}
+
+void YGNodeStyleSetGridRowStart(YGNodeRef node, int32_t gridRowStart) {
+  updateStyle<&Style::gridRowStart, &Style::setGridRowStart>(
+      node, GridLine::fromInteger(gridRowStart));
+}
+
+void YGNodeStyleSetGridRowStartAuto(YGNodeRef node) {
+  updateStyle<&Style::gridRowStart, &Style::setGridRowStart>(
+      node, GridLine::auto_());
+}
+
+void YGNodeStyleSetGridRowStartSpan(YGNodeRef node, int32_t span) {
+  updateStyle<&Style::gridRowStart, &Style::setGridRowStart>(
+      node, GridLine::span(span));
+}
+
+int32_t YGNodeStyleGetGridRowStart(YGNodeConstRef node) {
+  const auto& gridLine = resolveRef(node)->style().gridRowStart();
+  return gridLine.isInteger() ? gridLine.integer : 0;
+}
+
+void YGNodeStyleSetGridRowEnd(YGNodeRef node, int32_t gridRowEnd) {
+  updateStyle<&Style::gridRowEnd, &Style::setGridRowEnd>(
+      node, GridLine::fromInteger(gridRowEnd));
+}
+
+void YGNodeStyleSetGridRowEndAuto(YGNodeRef node) {
+  updateStyle<&Style::gridRowEnd, &Style::setGridRowEnd>(
+      node, GridLine::auto_());
+}
+
+void YGNodeStyleSetGridRowEndSpan(YGNodeRef node, int32_t span) {
+  updateStyle<&Style::gridRowEnd, &Style::setGridRowEnd>(
+      node, GridLine::span(span));
+}
+
+int32_t YGNodeStyleGetGridRowEnd(YGNodeConstRef node) {
+  const auto& gridLine = resolveRef(node)->style().gridRowEnd();
+  return gridLine.isInteger() ? gridLine.integer : 0;
+}
+
+// Grid Container Properties
+
+namespace {
+
+GridTrackSize gridTrackSizeFromTypeAndValue(YGGridTrackType type, float value) {
+  switch (type) {
+    case YGGridTrackTypePoints:
+      return GridTrackSize::length(value);
+    case YGGridTrackTypePercent:
+      return GridTrackSize::percent(value);
+    case YGGridTrackTypeFr:
+      return GridTrackSize::fr(value);
+    case YGGridTrackTypeAuto:
+      return GridTrackSize::auto_();
+    case YGGridTrackTypeMinmax:
+      return GridTrackSize::auto_();
+  }
+  fatalWithMessage("Unknown YGGridTrackType");
+}
+
+StyleSizeLength styleSizeLengthFromTypeAndValue(
+    YGGridTrackType type,
+    float value) {
+  switch (type) {
+    case YGGridTrackTypePoints:
+      return StyleSizeLength::points(value);
+    case YGGridTrackTypePercent:
+      return StyleSizeLength::percent(value);
+    case YGGridTrackTypeFr:
+      return StyleSizeLength::stretch(value);
+    case YGGridTrackTypeAuto:
+      return StyleSizeLength::ofAuto();
+    case YGGridTrackTypeMinmax:
+      return StyleSizeLength::ofAuto();
+  }
+  fatalWithMessage("Unknown YGGridTrackType");
+}
+
+} // namespace
+
+// GridTemplateColumns
+
+void YGNodeStyleSetGridTemplateColumnsCount(YGNodeRef node, size_t count) {
+  resolveRef(node)->style().resizeGridTemplateColumns(count);
+  resolveRef(node)->markDirtyAndPropagate();
+}
+
+void YGNodeStyleSetGridTemplateColumn(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType type,
+    float value) {
+  resolveRef(node)->style().setGridTemplateColumnAt(
+      index, gridTrackSizeFromTypeAndValue(type, value));
+  resolveRef(node)->markDirtyAndPropagate();
+}
+
+void YGNodeStyleSetGridTemplateColumnMinMax(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType minType,
+    float minValue,
+    YGGridTrackType maxType,
+    float maxValue) {
+  resolveRef(node)->style().setGridTemplateColumnAt(
+      index,
+      GridTrackSize::minmax(
+          styleSizeLengthFromTypeAndValue(minType, minValue),
+          styleSizeLengthFromTypeAndValue(maxType, maxValue)));
+  resolveRef(node)->markDirtyAndPropagate();
+}
+
+// GridTemplateRows
+
+void YGNodeStyleSetGridTemplateRowsCount(YGNodeRef node, size_t count) {
+  resolveRef(node)->style().resizeGridTemplateRows(count);
+  resolveRef(node)->markDirtyAndPropagate();
+}
+
+void YGNodeStyleSetGridTemplateRow(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType type,
+    float value) {
+  resolveRef(node)->style().setGridTemplateRowAt(
+      index, gridTrackSizeFromTypeAndValue(type, value));
+  resolveRef(node)->markDirtyAndPropagate();
+}
+
+void YGNodeStyleSetGridTemplateRowMinMax(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType minType,
+    float minValue,
+    YGGridTrackType maxType,
+    float maxValue) {
+  resolveRef(node)->style().setGridTemplateRowAt(
+      index,
+      GridTrackSize::minmax(
+          styleSizeLengthFromTypeAndValue(minType, minValue),
+          styleSizeLengthFromTypeAndValue(maxType, maxValue)));
+  resolveRef(node)->markDirtyAndPropagate();
+}
+
+// GridAutoColumns
+
+void YGNodeStyleSetGridAutoColumnsCount(YGNodeRef node, size_t count) {
+  resolveRef(node)->style().resizeGridAutoColumns(count);
+  resolveRef(node)->markDirtyAndPropagate();
+}
+
+void YGNodeStyleSetGridAutoColumn(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType type,
+    float value) {
+  resolveRef(node)->style().setGridAutoColumnAt(
+      index, gridTrackSizeFromTypeAndValue(type, value));
+  resolveRef(node)->markDirtyAndPropagate();
+}
+
+void YGNodeStyleSetGridAutoColumnMinMax(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType minType,
+    float minValue,
+    YGGridTrackType maxType,
+    float maxValue) {
+  resolveRef(node)->style().setGridAutoColumnAt(
+      index,
+      GridTrackSize::minmax(
+          styleSizeLengthFromTypeAndValue(minType, minValue),
+          styleSizeLengthFromTypeAndValue(maxType, maxValue)));
+  resolveRef(node)->markDirtyAndPropagate();
+}
+
+// GridAutoRows
+
+void YGNodeStyleSetGridAutoRowsCount(YGNodeRef node, size_t count) {
+  resolveRef(node)->style().resizeGridAutoRows(count);
+  resolveRef(node)->markDirtyAndPropagate();
+}
+
+void YGNodeStyleSetGridAutoRow(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType type,
+    float value) {
+  resolveRef(node)->style().setGridAutoRowAt(
+      index, gridTrackSizeFromTypeAndValue(type, value));
+  resolveRef(node)->markDirtyAndPropagate();
+}
+
+void YGNodeStyleSetGridAutoRowMinMax(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType minType,
+    float minValue,
+    YGGridTrackType maxType,
+    float maxValue) {
+  resolveRef(node)->style().setGridAutoRowAt(
+      index,
+      GridTrackSize::minmax(
+          styleSizeLengthFromTypeAndValue(minType, minValue),
+          styleSizeLengthFromTypeAndValue(maxType, maxValue)));
+  resolveRef(node)->markDirtyAndPropagate();
+}

package/ReactCommon/yoga/yoga/YGNodeStyle.h

@@ -8,7 +8,7 @@
 #pragma once
 
 #include <stddef.h>
-
+#include <yoga/YGEnums.h>
 #include <yoga/YGNode.h>
 #include <yoga/YGValue.h>
 
@@ -29,6 +29,14 @@ YG_EXPORT void YGNodeStyleSetJustifyContent(
     YGJustify justifyContent);
 YG_EXPORT YGJustify YGNodeStyleGetJustifyContent(YGNodeConstRef node);
 
+YG_EXPORT void YGNodeStyleSetJustifyItems(
+    YGNodeRef node,
+    YGJustify justifyItems);
+YG_EXPORT YGJustify YGNodeStyleGetJustifyItems(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetJustifySelf(YGNodeRef node, YGJustify justifySelf);
+YG_EXPORT YGJustify YGNodeStyleGetJustifySelf(YGNodeConstRef node);
+
 YG_EXPORT void YGNodeStyleSetAlignContent(YGNodeRef node, YGAlign alignContent);
 YG_EXPORT YGAlign YGNodeStyleGetAlignContent(YGNodeConstRef node);
 
@@ -148,4 +156,88 @@ YG_EXPORT YGValue YGNodeStyleGetMaxHeight(YGNodeConstRef node);
 YG_EXPORT void YGNodeStyleSetAspectRatio(YGNodeRef node, float aspectRatio);
 YG_EXPORT float YGNodeStyleGetAspectRatio(YGNodeConstRef node);
 
+// Grid Item Properties
+YG_EXPORT void YGNodeStyleSetGridColumnStart(
+    YGNodeRef node,
+    int gridColumnStart);
+YG_EXPORT void YGNodeStyleSetGridColumnStartAuto(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetGridColumnStartSpan(YGNodeRef node, int span);
+YG_EXPORT int YGNodeStyleGetGridColumnStart(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetGridColumnEnd(YGNodeRef node, int gridColumnEnd);
+YG_EXPORT void YGNodeStyleSetGridColumnEndAuto(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetGridColumnEndSpan(YGNodeRef node, int span);
+YG_EXPORT int YGNodeStyleGetGridColumnEnd(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetGridRowStart(YGNodeRef node, int gridRowStart);
+YG_EXPORT void YGNodeStyleSetGridRowStartAuto(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetGridRowStartSpan(YGNodeRef node, int span);
+YG_EXPORT int YGNodeStyleGetGridRowStart(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetGridRowEnd(YGNodeRef node, int gridRowEnd);
+YG_EXPORT void YGNodeStyleSetGridRowEndAuto(YGNodeRef node);
+YG_EXPORT void YGNodeStyleSetGridRowEndSpan(YGNodeRef node, int span);
+YG_EXPORT int YGNodeStyleGetGridRowEnd(YGNodeConstRef node);
+
+// Grid Container Properties
+YG_EXPORT void YGNodeStyleSetGridTemplateColumnsCount(
+    YGNodeRef node,
+    size_t count);
+YG_EXPORT void YGNodeStyleSetGridTemplateColumn(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType type,
+    float value);
+YG_EXPORT void YGNodeStyleSetGridTemplateColumnMinMax(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType minType,
+    float minValue,
+    YGGridTrackType maxType,
+    float maxValue);
+
+YG_EXPORT void YGNodeStyleSetGridTemplateRowsCount(
+    YGNodeRef node,
+    size_t count);
+YG_EXPORT void YGNodeStyleSetGridTemplateRow(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType type,
+    float value);
+YG_EXPORT void YGNodeStyleSetGridTemplateRowMinMax(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType minType,
+    float minValue,
+    YGGridTrackType maxType,
+    float maxValue);
+
+YG_EXPORT void YGNodeStyleSetGridAutoColumnsCount(YGNodeRef node, size_t count);
+YG_EXPORT void YGNodeStyleSetGridAutoColumn(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType type,
+    float value);
+YG_EXPORT void YGNodeStyleSetGridAutoColumnMinMax(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType minType,
+    float minValue,
+    YGGridTrackType maxType,
+    float maxValue);
+
+YG_EXPORT void YGNodeStyleSetGridAutoRowsCount(YGNodeRef node, size_t count);
+YG_EXPORT void YGNodeStyleSetGridAutoRow(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType type,
+    float value);
+YG_EXPORT void YGNodeStyleSetGridAutoRowMinMax(
+    YGNodeRef node,
+    size_t index,
+    YGGridTrackType minType,
+    float minValue,
+    YGGridTrackType maxType,
+    float maxValue);
+
 YG_EXTERN_C_END

package/ReactCommon/yoga/yoga/algorithm/AbsoluteLayout.cpp

@@ -23,7 +23,11 @@ static inline void setFlexStartLayoutPosition(
                        axis, direction, containingBlockWidth) +
       parent->getLayout().border(flexStartEdge(axis));
 
-  if (!child->hasErrata(Errata::AbsolutePositionWithoutInsetsExcludesPadding)) {
+  // https://www.w3.org/TR/css-grid-1/#abspos
+  // absolute positioned grid items are positioned relative to the padding edge
+  // of the grid container
+  if (!child->hasErrata(Errata::AbsolutePositionWithoutInsetsExcludesPadding) &&
+      parent->style().display() != Display::Grid) {
     position += parent->getLayout().padding(flexStartEdge(axis));
   }
 
@@ -40,7 +44,11 @@ static inline void setFlexEndLayoutPosition(
       child->style().computeFlexEndMargin(
           axis, direction, containingBlockWidth);
 
-  if (!child->hasErrata(Errata::AbsolutePositionWithoutInsetsExcludesPadding)) {
+  // https://www.w3.org/TR/css-grid-1/#abspos
+  // absolute positioned grid items are positioned relative to the padding edge
+  // of the grid container
+  if (!child->hasErrata(Errata::AbsolutePositionWithoutInsetsExcludesPadding) &&
+      parent->style().display() != Display::Grid) {
     flexEndPosition += parent->getLayout().padding(flexEndEdge(axis));
   }
 
@@ -60,7 +68,11 @@ static inline void setCenterLayoutPosition(
       parent->getLayout().border(flexStartEdge(axis)) -
       parent->getLayout().border(flexEndEdge(axis));
 
-  if (!child->hasErrata(Errata::AbsolutePositionWithoutInsetsExcludesPadding)) {
+  // https://www.w3.org/TR/css-grid-1/#abspos
+  // absolute positioned grid items are positioned relative to the padding edge
+  // of the grid container
+  if (!child->hasErrata(Errata::AbsolutePositionWithoutInsetsExcludesPadding) &&
+      parent->style().display() != Display::Grid) {
     parentContentBoxSize -= parent->getLayout().padding(flexStartEdge(axis));
     parentContentBoxSize -= parent->getLayout().padding(flexEndEdge(axis));
   }
@@ -74,7 +86,11 @@ static inline void setCenterLayoutPosition(
       child->style().computeFlexStartMargin(
           axis, direction, containingBlockWidth);
 
-  if (!child->hasErrata(Errata::AbsolutePositionWithoutInsetsExcludesPadding)) {
+  // https://www.w3.org/TR/css-grid-1/#abspos
+  // absolute positioned grid items are positioned relative to the padding edge
+  // of the grid container
+  if (!child->hasErrata(Errata::AbsolutePositionWithoutInsetsExcludesPadding) &&
+      parent->style().display() != Display::Grid) {
     position += parent->getLayout().padding(flexStartEdge(axis));
   }
 
@@ -87,13 +103,19 @@ static void justifyAbsoluteChild(
     const Direction direction,
     const FlexDirection mainAxis,
     const float containingBlockWidth) {
-  const Justify parentJustifyContent = parent->style().justifyContent();
-  switch (parentJustifyContent) {
+  const Justify justify = parent->style().display() == Display::Grid
+      ? resolveChildJustification(parent, child)
+      : parent->style().justifyContent();
+  switch (justify) {
+    case Justify::Start:
+    case Justify::Auto:
+    case Justify::Stretch:
     case Justify::FlexStart:
     case Justify::SpaceBetween:
       setFlexStartLayoutPosition(
           parent, child, direction, mainAxis, containingBlockWidth);
       break;
+    case Justify::End:
     case Justify::FlexEnd:
       setFlexEndLayoutPosition(
           parent, child, direction, mainAxis, containingBlockWidth);
@@ -124,6 +146,7 @@ static void alignAbsoluteChild(
   }
 
   switch (itemAlign) {
+    case Align::Start:
     case Align::Auto:
     case Align::FlexStart:
     case Align::Baseline:
@@ -134,6 +157,7 @@ static void alignAbsoluteChild(
       setFlexStartLayoutPosition(
           parent, child, direction, crossAxis, containingBlockWidth);
       break;
+    case Align::End:
     case Align::FlexEnd:
       setFlexEndLayoutPosition(
           parent, child, direction, crossAxis, containingBlockWidth);
@@ -234,9 +258,15 @@ void layoutAbsoluteChild(
     LayoutData& layoutMarkerData,
     const uint32_t depth,
     const uint32_t generationCount) {
-  const FlexDirection mainAxis =
-      resolveDirection(node->style().flexDirection(), direction);
-  const FlexDirection crossAxis = resolveCrossDirection(mainAxis, direction);
+  // For grid containers, use inline (Row) and block (Column) axes for
+  // positioning, since grid alignment properties (justify-self, align-self)
+  // operate on inline/block axes, not main/cross axes based on flex-direction.
+  const FlexDirection mainAxis = node->style().display() == Display::Grid
+      ? resolveDirection(FlexDirection::Row, direction)
+      : resolveDirection(node->style().flexDirection(), direction);
+  const FlexDirection crossAxis = node->style().display() == Display::Grid
+      ? FlexDirection::Column
+      : resolveCrossDirection(mainAxis, direction);
   const bool isMainAxisRow = isRow(mainAxis);
 
   float childWidth = YGUndefined;
@@ -528,6 +558,7 @@ bool layoutAbsoluteDescendants(
       // we need to mutate these descendents. Make sure the path of
       // nodes to them is mutable before positioning.
       child->cloneChildrenIfNeeded();
+      cleanupContentsNodesRecursively(child);
       const Direction childDirection =
           child->resolveDirection(currentNodeDirection);
       // By now all descendants of the containing block that are not absolute

package/ReactCommon/yoga/yoga/algorithm/Align.h

@@ -20,12 +20,23 @@ inline Align resolveChildAlignment(
   const Align align = child->style().alignSelf() == Align::Auto
       ? node->style().alignItems()
       : child->style().alignSelf();
-  if (align == Align::Baseline && isColumn(node->style().flexDirection())) {
+
+  if (node->style().display() == Display::Flex && align == Align::Baseline &&
+      isColumn(node->style().flexDirection())) {
     return Align::FlexStart;
   }
+
   return align;
 }
 
+inline Justify resolveChildJustification(
+    const yoga::Node* node,
+    const yoga::Node* child) {
+  return child->style().justifySelf() == Justify::Auto
+      ? node->style().justifyItems()
+      : child->style().justifySelf();
+}
+
 /**
  * Fallback alignment to use on overflow
  * https://www.w3.org/TR/css-align-3/#distribution-values