feat: calc layout calculations

Author: paradowstack

enums.py

@@ -16,6 +16,7 @@
         "MaxContent",
         "FitContent",
         "Stretch",
+        "Calc",
     ],
     "FlexDirection": ["Column", "ColumnReverse", "Row", "RowReverse"],
     "Justify": [

yoga/YGCalc.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <yoga/YGMacros.h>
+
+YG_EXTERN_C_BEGIN
+
+/**
+ * Structure used to represent a calc() expression with mixed units.
+ */
+typedef struct YGCalc {
+  float px;
+  float percent;
+  float vw;
+  float vh;
+} YGCalc;
+
+YG_EXTERN_C_END

yoga/YGConfig.cpp

@@ -47,6 +47,36 @@ float YGConfigGetPointScaleFactor(const YGConfigConstRef config) {
   return resolveRef(config)->getPointScaleFactor();
 }
 
+void YGConfigSetViewportWidth(
+    const YGConfigRef config,
+    const float viewportWidth) {
+  yoga::assertFatalWithConfig(
+      resolveRef(config),
+      viewportWidth >= 0.0f,
+      "Viewport width should not be less than zero");
+
+  resolveRef(config)->setViewportWidth(viewportWidth);
+}
+
+float YGConfigGetViewportWidth(const YGConfigConstRef config) {
+  return resolveRef(config)->getViewportWidth();
+}
+
+void YGConfigSetViewportHeight(
+    const YGConfigRef config,
+    const float viewportHeight) {
+  yoga::assertFatalWithConfig(
+      resolveRef(config),
+      viewportHeight >= 0.0f,
+      "Viewport height should not be less than zero");
+
+  resolveRef(config)->setViewportHeight(viewportHeight);
+}
+
+float YGConfigGetViewportHeight(const YGConfigConstRef config) {
+  return resolveRef(config)->getViewportHeight();
+}
+
 void YGConfigSetErrata(YGConfigRef config, YGErrata errata) {
   resolveRef(config)->setErrata(scopedEnum(errata));
 }

yoga/YGConfig.h

@@ -75,6 +75,30 @@ YG_EXPORT void YGConfigSetPointScaleFactor(
  */
 YG_EXPORT float YGConfigGetPointScaleFactor(YGConfigConstRef config);
 
+/**
+ * Sets the viewport width used for resolving CSS calc() expressions with
+ * viewport units (vw). This should be the width of the root viewport in points.
+ */
+YG_EXPORT void YGConfigSetViewportWidth(YGConfigRef config, float viewportWidth);
+
+/**
+ * Gets the currently set viewport width.
+ */
+YG_EXPORT float YGConfigGetViewportWidth(YGConfigConstRef config);
+
+/**
+ * Sets the viewport height used for resolving CSS calc() expressions with
+ * viewport units (vh). This should be the height of the root viewport in points.
+ */
+YG_EXPORT void YGConfigSetViewportHeight(
+    YGConfigRef config,
+    float viewportHeight);
+
+/**
+ * Gets the currently set viewport height.
+ */
+YG_EXPORT float YGConfigGetViewportHeight(YGConfigConstRef config);
+
 /**
  * Configures how Yoga balances W3C conformance vs compatibility with layouts
  * created against earlier versions of Yoga.

yoga/YGEnums.cpp

@@ -251,6 +251,8 @@ const char* YGUnitToString(const YGUnit value) {
       return "fit-content";
     case YGUnitStretch:
       return "stretch";
+    case YGUnitCalc:
+      return "calc";
   }
   return "unknown";
 }

yoga/YGEnums.h

@@ -134,7 +134,8 @@ YG_ENUM_DECL(
     YGUnitAuto,
     YGUnitMaxContent,
     YGUnitFitContent,
-    YGUnitStretch)
+    YGUnitStretch,
+    YGUnitCalc)
 
 YG_ENUM_DECL(
     YGWrap,

yoga/YGNodeStyle.cpp

@@ -8,12 +8,21 @@
 #include <yoga/Yoga.h>
 #include <yoga/debug/AssertFatal.h>
 #include <yoga/node/Node.h>
+#include <yoga/style/StyleCalcLength.h>
 
 using namespace facebook;
 using namespace facebook::yoga;
 
 namespace {
 
+inline StyleCalcLength YGCalcToStyleCalcLength(YGCalc calc) {
+  return {
+      FloatOptional{calc.px},
+      FloatOptional{calc.percent},
+      FloatOptional{calc.vw},
+      FloatOptional{calc.vh}};
+}
+
 template <auto GetterT, auto SetterT, typename ValueT>
 void updateStyle(YGNodeRef node, ValueT value) {
   auto& style = resolveRef(node)->style();
@@ -207,6 +216,11 @@ void YGNodeStyleSetFlexBasisStretch(const YGNodeRef node) {
       node, StyleSizeLength::ofStretch());
 }
 
+void YGNodeStyleSetFlexBasisCalc(const YGNodeRef node, const YGCalc calc) {
+  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
+      node, StyleSizeLength::calc(YGCalcToStyleCalcLength(calc)));
+}
+
 YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) {
   return (YGValue)resolveRef(node)->style().flexBasis();
 }
@@ -226,6 +240,11 @@ void YGNodeStyleSetPositionAuto(YGNodeRef node, YGEdge edge) {
       node, scopedEnum(edge), StyleLength::ofAuto());
 }
 
+void YGNodeStyleSetPositionCalc(YGNodeRef node, YGEdge edge, YGCalc calc) {
+  updateStyle<&Style::position, &Style::setPosition>(
+      node, scopedEnum(edge), StyleLength::calc(YGCalcToStyleCalcLength(calc)));
+}
+
 YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) {
   return (YGValue)resolveRef(node)->style().position(scopedEnum(edge));
 }
@@ -245,6 +264,11 @@ void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge) {
       node, scopedEnum(edge), StyleLength::ofAuto());
 }
 
+void YGNodeStyleSetMarginCalc(YGNodeRef node, YGEdge edge, YGCalc calc) {
+  updateStyle<&Style::margin, &Style::setMargin>(
+      node, scopedEnum(edge), StyleLength::calc(YGCalcToStyleCalcLength(calc)));
+}
+
 YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) {
   return (YGValue)resolveRef(node)->style().margin(scopedEnum(edge));
 }
@@ -259,6 +283,11 @@ void YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge, float percent) {
       node, scopedEnum(edge), StyleLength::percent(percent));
 }
 
+void YGNodeStyleSetPaddingCalc(YGNodeRef node, YGEdge edge, YGCalc calc) {
+  updateStyle<&Style::padding, &Style::setPadding>(
+      node, scopedEnum(edge), StyleLength::calc(YGCalcToStyleCalcLength(calc)));
+}
+
 YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge) {
   return (YGValue)resolveRef(node)->style().padding(scopedEnum(edge));
 }
@@ -271,6 +300,14 @@ void YGNodeStyleSetBorder(
       node, scopedEnum(edge), StyleLength::points(border));
 }
 
+void YGNodeStyleSetBorderCalc(
+    const YGNodeRef node,
+    const YGEdge edge,
+    const YGCalc calc) {
+  updateStyle<&Style::border, &Style::setBorder>(
+      node, scopedEnum(edge), StyleLength::calc(YGCalcToStyleCalcLength(calc)));
+}
+
 float YGNodeStyleGetBorder(const YGNodeConstRef node, const YGEdge edge) {
   auto border = resolveRef(node)->style().border(scopedEnum(edge));
   if (border.isUndefined() || border.isAuto()) {
@@ -293,6 +330,13 @@ void YGNodeStyleSetGapPercent(YGNodeRef node, YGGutter gutter, float percent) {
       node, scopedEnum(gutter), StyleLength::percent(percent));
 }
 
+void YGNodeStyleSetGapCalc(YGNodeRef node, YGGutter gutter, YGCalc calc) {
+  updateStyle<&Style::gap, &Style::setGap>(
+      node,
+      scopedEnum(gutter),
+      StyleLength::calc(YGCalcToStyleCalcLength(calc)));
+}
+
 YGValue YGNodeStyleGetGap(const YGNodeConstRef node, const YGGutter gutter) {
   return (YGValue)resolveRef(node)->style().gap(scopedEnum(gutter));
 }
@@ -346,6 +390,13 @@ void YGNodeStyleSetWidthStretch(YGNodeRef node) {
       node, Dimension::Width, StyleSizeLength::ofStretch());
 }
 
+void YGNodeStyleSetWidthCalc(YGNodeRef node, YGCalc calc) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node,
+      Dimension::Width,
+      StyleSizeLength::calc(YGCalcToStyleCalcLength(calc)));
+}
+
 YGValue YGNodeStyleGetWidth(YGNodeConstRef node) {
   return (YGValue)resolveRef(node)->style().dimension(Dimension::Width);
 }
@@ -380,6 +431,13 @@ void YGNodeStyleSetHeightStretch(YGNodeRef node) {
       node, Dimension::Height, StyleSizeLength::ofStretch());
 }
 
+void YGNodeStyleSetHeightCalc(YGNodeRef node, YGCalc calc) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node,
+      Dimension::Height,
+      StyleSizeLength::calc(YGCalcToStyleCalcLength(calc)));
+}
+
 YGValue YGNodeStyleGetHeight(YGNodeConstRef node) {
   return (YGValue)resolveRef(node)->style().dimension(Dimension::Height);
 }
@@ -409,6 +467,13 @@ void YGNodeStyleSetMinWidthStretch(const YGNodeRef node) {
       node, Dimension::Width, StyleSizeLength::ofStretch());
 }
 
+void YGNodeStyleSetMinWidthCalc(const YGNodeRef node, const YGCalc calc) {
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
+      node,
+      Dimension::Width,
+      StyleSizeLength::calc(YGCalcToStyleCalcLength(calc)));
+}
+
 YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) {
   return (YGValue)resolveRef(node)->style().minDimension(Dimension::Width);
 }
@@ -440,6 +505,13 @@ void YGNodeStyleSetMinHeightStretch(const YGNodeRef node) {
       node, Dimension::Height, StyleSizeLength::ofStretch());
 }
 
+void YGNodeStyleSetMinHeightCalc(const YGNodeRef node, const YGCalc calc) {
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
+      node,
+      Dimension::Height,
+      StyleSizeLength::calc(YGCalcToStyleCalcLength(calc)));
+}
+
 YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) {
   return (YGValue)resolveRef(node)->style().minDimension(Dimension::Height);
 }
@@ -469,6 +541,13 @@ void YGNodeStyleSetMaxWidthStretch(const YGNodeRef node) {
       node, Dimension::Width, StyleSizeLength::ofStretch());
 }
 
+void YGNodeStyleSetMaxWidthCalc(const YGNodeRef node, const YGCalc calc) {
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
+      node,
+      Dimension::Width,
+      StyleSizeLength::calc(YGCalcToStyleCalcLength(calc)));
+}
+
 YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) {
   return (YGValue)resolveRef(node)->style().maxDimension(Dimension::Width);
 }
@@ -500,6 +579,13 @@ void YGNodeStyleSetMaxHeightStretch(const YGNodeRef node) {
       node, Dimension::Height, StyleSizeLength::ofStretch());
 }
 
+void YGNodeStyleSetMaxHeightCalc(const YGNodeRef node, const YGCalc calc) {
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
+      node,
+      Dimension::Height,
+      StyleSizeLength::calc(YGCalcToStyleCalcLength(calc)));
+}
+
 YGValue YGNodeStyleGetMaxHeight(const YGNodeConstRef node) {
   return (YGValue)resolveRef(node)->style().maxDimension(Dimension::Height);
 }