pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/yoga/yoga/YGNodeStyle.cpp

@@ -0,0 +1,405 @@
+/*
+ * 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.
+ */
+
+#include <yoga/Yoga.h>
+#include <yoga/debug/AssertFatal.h>
+#include <yoga/node/Node.h>
+
+using namespace facebook;
+using namespace facebook::yoga;
+
+namespace {
+
+template <auto GetterT, auto SetterT, typename ValueT>
+void updateStyle(YGNodeRef node, ValueT value) {
+  auto& style = resolveRef(node)->style();
+  if ((style.*GetterT)() != value) {
+    (style.*SetterT)(value);
+    resolveRef(node)->markDirtyAndPropagate();
+  }
+}
+
+template <auto GetterT, auto SetterT, typename IdxT, typename ValueT>
+void updateStyle(YGNodeRef node, IdxT idx, ValueT value) {
+  auto& style = resolveRef(node)->style();
+  if ((style.*GetterT)(idx) != value) {
+    (style.*SetterT)(idx, value);
+    resolveRef(node)->markDirtyAndPropagate();
+  }
+}
+
+} // namespace
+
+void YGNodeCopyStyle(YGNodeRef dstNode, YGNodeConstRef srcNode) {
+  auto dst = resolveRef(dstNode);
+  auto src = resolveRef(srcNode);
+
+  if (dst->style() != src->style()) {
+    dst->setStyle(src->style());
+    dst->markDirtyAndPropagate();
+  }
+}
+
+void YGNodeStyleSetDirection(const YGNodeRef node, const YGDirection value) {
+  updateStyle<&Style::direction, &Style::setDirection>(node, scopedEnum(value));
+}
+
+YGDirection YGNodeStyleGetDirection(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().direction());
+}
+
+void YGNodeStyleSetFlexDirection(
+    const YGNodeRef node,
+    const YGFlexDirection flexDirection) {
+  updateStyle<&Style::flexDirection, &Style::setFlexDirection>(
+      node, scopedEnum(flexDirection));
+}
+
+YGFlexDirection YGNodeStyleGetFlexDirection(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().flexDirection());
+}
+
+void YGNodeStyleSetJustifyContent(
+    const YGNodeRef node,
+    const YGJustify justifyContent) {
+  updateStyle<&Style::justifyContent, &Style::setJustifyContent>(
+      node, scopedEnum(justifyContent));
+}
+
+YGJustify YGNodeStyleGetJustifyContent(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().justifyContent());
+}
+
+void YGNodeStyleSetAlignContent(
+    const YGNodeRef node,
+    const YGAlign alignContent) {
+  updateStyle<&Style::alignContent, &Style::setAlignContent>(
+      node, scopedEnum(alignContent));
+}
+
+YGAlign YGNodeStyleGetAlignContent(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().alignContent());
+}
+
+void YGNodeStyleSetAlignItems(const YGNodeRef node, const YGAlign alignItems) {
+  updateStyle<&Style::alignItems, &Style::setAlignItems>(
+      node, scopedEnum(alignItems));
+}
+
+YGAlign YGNodeStyleGetAlignItems(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().alignItems());
+}
+
+void YGNodeStyleSetAlignSelf(const YGNodeRef node, const YGAlign alignSelf) {
+  updateStyle<&Style::alignSelf, &Style::setAlignSelf>(
+      node, scopedEnum(alignSelf));
+}
+
+YGAlign YGNodeStyleGetAlignSelf(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().alignSelf());
+}
+
+void YGNodeStyleSetPositionType(
+    const YGNodeRef node,
+    const YGPositionType positionType) {
+  updateStyle<&Style::positionType, &Style::setPositionType>(
+      node, scopedEnum(positionType));
+}
+
+YGPositionType YGNodeStyleGetPositionType(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().positionType());
+}
+
+void YGNodeStyleSetFlexWrap(const YGNodeRef node, const YGWrap flexWrap) {
+  updateStyle<&Style::flexWrap, &Style::setFlexWrap>(
+      node, scopedEnum(flexWrap));
+}
+
+YGWrap YGNodeStyleGetFlexWrap(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().flexWrap());
+}
+
+void YGNodeStyleSetOverflow(const YGNodeRef node, const YGOverflow overflow) {
+  updateStyle<&Style::overflow, &Style::setOverflow>(
+      node, scopedEnum(overflow));
+}
+
+YGOverflow YGNodeStyleGetOverflow(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().overflow());
+}
+
+void YGNodeStyleSetDisplay(const YGNodeRef node, const YGDisplay display) {
+  updateStyle<&Style::display, &Style::setDisplay>(node, scopedEnum(display));
+}
+
+YGDisplay YGNodeStyleGetDisplay(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().display());
+}
+
+void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) {
+  updateStyle<&Style::flex, &Style::setFlex>(node, FloatOptional{flex});
+}
+
+float YGNodeStyleGetFlex(const YGNodeConstRef nodeRef) {
+  const auto node = resolveRef(nodeRef);
+  return node->style().flex().isUndefined() ? YGUndefined
+                                            : node->style().flex().unwrap();
+}
+
+void YGNodeStyleSetFlexGrow(const YGNodeRef node, const float flexGrow) {
+  updateStyle<&Style::flexGrow, &Style::setFlexGrow>(
+      node, FloatOptional{flexGrow});
+}
+
+float YGNodeStyleGetFlexGrow(const YGNodeConstRef nodeRef) {
+  const auto node = resolveRef(nodeRef);
+  return node->style().flexGrow().isUndefined()
+      ? Style::DefaultFlexGrow
+      : node->style().flexGrow().unwrap();
+}
+
+void YGNodeStyleSetFlexShrink(const YGNodeRef node, const float flexShrink) {
+  updateStyle<&Style::flexShrink, &Style::setFlexShrink>(
+      node, FloatOptional{flexShrink});
+}
+
+float YGNodeStyleGetFlexShrink(const YGNodeConstRef nodeRef) {
+  const auto node = resolveRef(nodeRef);
+  return node->style().flexShrink().isUndefined()
+      ? (node->getConfig()->useWebDefaults() ? Style::WebDefaultFlexShrink
+                                             : Style::DefaultFlexShrink)
+      : node->style().flexShrink().unwrap();
+}
+
+void YGNodeStyleSetFlexBasis(const YGNodeRef node, const float flexBasis) {
+  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
+      node, StyleLength::points(flexBasis));
+}
+
+void YGNodeStyleSetFlexBasisPercent(
+    const YGNodeRef node,
+    const float flexBasisPercent) {
+  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
+      node, StyleLength::percent(flexBasisPercent));
+}
+
+void YGNodeStyleSetFlexBasisAuto(const YGNodeRef node) {
+  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
+      node, StyleLength::ofAuto());
+}
+
+YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) {
+  return (YGValue)resolveRef(node)->style().flexBasis();
+}
+
+void YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge, float points) {
+  updateStyle<&Style::position, &Style::setPosition>(
+      node, scopedEnum(edge), StyleLength::points(points));
+}
+
+void YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge, float percent) {
+  updateStyle<&Style::position, &Style::setPosition>(
+      node, scopedEnum(edge), StyleLength::percent(percent));
+}
+
+void YGNodeStyleSetPositionAuto(YGNodeRef node, YGEdge edge) {
+  updateStyle<&Style::position, &Style::setPosition>(
+      node, scopedEnum(edge), StyleLength::ofAuto());
+}
+
+YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge) {
+  return (YGValue)resolveRef(node)->style().position(scopedEnum(edge));
+}
+
+void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float points) {
+  updateStyle<&Style::margin, &Style::setMargin>(
+      node, scopedEnum(edge), StyleLength::points(points));
+}
+
+void YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge, float percent) {
+  updateStyle<&Style::margin, &Style::setMargin>(
+      node, scopedEnum(edge), StyleLength::percent(percent));
+}
+
+void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge) {
+  updateStyle<&Style::margin, &Style::setMargin>(
+      node, scopedEnum(edge), StyleLength::ofAuto());
+}
+
+YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge) {
+  return (YGValue)resolveRef(node)->style().margin(scopedEnum(edge));
+}
+
+void YGNodeStyleSetPadding(YGNodeRef node, YGEdge edge, float points) {
+  updateStyle<&Style::padding, &Style::setPadding>(
+      node, scopedEnum(edge), StyleLength::points(points));
+}
+
+void YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge, float percent) {
+  updateStyle<&Style::padding, &Style::setPadding>(
+      node, scopedEnum(edge), StyleLength::percent(percent));
+}
+
+YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge) {
+  return (YGValue)resolveRef(node)->style().padding(scopedEnum(edge));
+}
+
+void YGNodeStyleSetBorder(
+    const YGNodeRef node,
+    const YGEdge edge,
+    const float border) {
+  updateStyle<&Style::border, &Style::setBorder>(
+      node, scopedEnum(edge), StyleLength::points(border));
+}
+
+float YGNodeStyleGetBorder(const YGNodeConstRef node, const YGEdge edge) {
+  auto border = resolveRef(node)->style().border(scopedEnum(edge));
+  if (border.isUndefined() || border.isAuto()) {
+    return YGUndefined;
+  }
+
+  return static_cast<YGValue>(border).value;
+}
+
+void YGNodeStyleSetGap(
+    const YGNodeRef node,
+    const YGGutter gutter,
+    const float gapLength) {
+  updateStyle<&Style::gap, &Style::setGap>(
+      node, scopedEnum(gutter), StyleLength::points(gapLength));
+}
+
+void YGNodeStyleSetGapPercent(YGNodeRef node, YGGutter gutter, float percent) {
+  updateStyle<&Style::gap, &Style::setGap>(
+      node, scopedEnum(gutter), StyleLength::percent(percent));
+}
+
+float YGNodeStyleGetGap(const YGNodeConstRef node, const YGGutter gutter) {
+  auto gapLength = resolveRef(node)->style().gap(scopedEnum(gutter));
+  if (gapLength.isUndefined() || gapLength.isAuto()) {
+    return YGUndefined;
+  }
+
+  return static_cast<YGValue>(gapLength).value;
+}
+
+void YGNodeStyleSetAspectRatio(const YGNodeRef node, const float aspectRatio) {
+  updateStyle<&Style::aspectRatio, &Style::setAspectRatio>(
+      node, FloatOptional{aspectRatio});
+}
+
+float YGNodeStyleGetAspectRatio(const YGNodeConstRef node) {
+  const FloatOptional op = resolveRef(node)->style().aspectRatio();
+  return op.isUndefined() ? YGUndefined : op.unwrap();
+}
+
+void YGNodeStyleSetBoxSizing(YGNodeRef node, YGBoxSizing boxSizing) {
+  updateStyle<&Style::boxSizing, &Style::setBoxSizing>(
+      node, scopedEnum(boxSizing));
+}
+
+YGBoxSizing YGNodeStyleGetBoxSizing(const YGNodeConstRef node) {
+  return unscopedEnum(resolveRef(node)->style().boxSizing());
+}
+
+void YGNodeStyleSetWidth(YGNodeRef node, float points) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node, Dimension::Width, StyleLength::points(points));
+}
+
+void YGNodeStyleSetWidthPercent(YGNodeRef node, float percent) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node, Dimension::Width, StyleLength::percent(percent));
+}
+
+void YGNodeStyleSetWidthAuto(YGNodeRef node) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node, Dimension::Width, StyleLength::ofAuto());
+}
+
+YGValue YGNodeStyleGetWidth(YGNodeConstRef node) {
+  return (YGValue)resolveRef(node)->style().dimension(Dimension::Width);
+}
+
+void YGNodeStyleSetHeight(YGNodeRef node, float points) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node, Dimension::Height, StyleLength::points(points));
+}
+
+void YGNodeStyleSetHeightPercent(YGNodeRef node, float percent) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node, Dimension::Height, StyleLength::percent(percent));
+}
+
+void YGNodeStyleSetHeightAuto(YGNodeRef node) {
+  updateStyle<&Style::dimension, &Style::setDimension>(
+      node, Dimension::Height, StyleLength::ofAuto());
+}
+
+YGValue YGNodeStyleGetHeight(YGNodeConstRef node) {
+  return (YGValue)resolveRef(node)->style().dimension(Dimension::Height);
+}
+
+void YGNodeStyleSetMinWidth(const YGNodeRef node, const float minWidth) {
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
+      node, Dimension::Width, StyleLength::points(minWidth));
+}
+
+void YGNodeStyleSetMinWidthPercent(const YGNodeRef node, const float minWidth) {
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
+      node, Dimension::Width, StyleLength::percent(minWidth));
+}
+
+YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) {
+  return (YGValue)resolveRef(node)->style().minDimension(Dimension::Width);
+}
+
+void YGNodeStyleSetMinHeight(const YGNodeRef node, const float minHeight) {
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
+      node, Dimension::Height, StyleLength::points(minHeight));
+}
+
+void YGNodeStyleSetMinHeightPercent(
+    const YGNodeRef node,
+    const float minHeight) {
+  updateStyle<&Style::minDimension, &Style::setMinDimension>(
+      node, Dimension::Height, StyleLength::percent(minHeight));
+}
+
+YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) {
+  return (YGValue)resolveRef(node)->style().minDimension(Dimension::Height);
+}
+
+void YGNodeStyleSetMaxWidth(const YGNodeRef node, const float maxWidth) {
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
+      node, Dimension::Width, StyleLength::points(maxWidth));
+}
+
+void YGNodeStyleSetMaxWidthPercent(const YGNodeRef node, const float maxWidth) {
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
+      node, Dimension::Width, StyleLength::percent(maxWidth));
+}
+
+YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) {
+  return (YGValue)resolveRef(node)->style().maxDimension(Dimension::Width);
+}
+
+void YGNodeStyleSetMaxHeight(const YGNodeRef node, const float maxHeight) {
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
+      node, Dimension::Height, StyleLength::points(maxHeight));
+}
+
+void YGNodeStyleSetMaxHeightPercent(
+    const YGNodeRef node,
+    const float maxHeight) {
+  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
+      node, Dimension::Height, StyleLength::percent(maxHeight));
+}
+
+YGValue YGNodeStyleGetMaxHeight(const YGNodeConstRef node) {
+  return (YGValue)resolveRef(node)->style().maxDimension(Dimension::Height);
+}

pythonnative/native/yoga/yoga/YGNodeStyle.h

@@ -0,0 +1,130 @@
+/*
+ * 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 <stddef.h>
+
+#include <yoga/YGNode.h>
+#include <yoga/YGValue.h>
+
+YG_EXTERN_C_BEGIN
+
+YG_EXPORT void YGNodeCopyStyle(YGNodeRef dstNode, YGNodeConstRef srcNode);
+
+YG_EXPORT void YGNodeStyleSetDirection(YGNodeRef node, YGDirection direction);
+YG_EXPORT YGDirection YGNodeStyleGetDirection(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetFlexDirection(
+    YGNodeRef node,
+    YGFlexDirection flexDirection);
+YG_EXPORT YGFlexDirection YGNodeStyleGetFlexDirection(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetJustifyContent(
+    YGNodeRef node,
+    YGJustify justifyContent);
+YG_EXPORT YGJustify YGNodeStyleGetJustifyContent(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetAlignContent(YGNodeRef node, YGAlign alignContent);
+YG_EXPORT YGAlign YGNodeStyleGetAlignContent(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetAlignItems(YGNodeRef node, YGAlign alignItems);
+YG_EXPORT YGAlign YGNodeStyleGetAlignItems(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetAlignSelf(YGNodeRef node, YGAlign alignSelf);
+YG_EXPORT YGAlign YGNodeStyleGetAlignSelf(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetPositionType(
+    YGNodeRef node,
+    YGPositionType positionType);
+YG_EXPORT YGPositionType YGNodeStyleGetPositionType(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetFlexWrap(YGNodeRef node, YGWrap flexWrap);
+YG_EXPORT YGWrap YGNodeStyleGetFlexWrap(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetOverflow(YGNodeRef node, YGOverflow overflow);
+YG_EXPORT YGOverflow YGNodeStyleGetOverflow(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetDisplay(YGNodeRef node, YGDisplay display);
+YG_EXPORT YGDisplay YGNodeStyleGetDisplay(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetFlex(YGNodeRef node, float flex);
+YG_EXPORT float YGNodeStyleGetFlex(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetFlexGrow(YGNodeRef node, float flexGrow);
+YG_EXPORT float YGNodeStyleGetFlexGrow(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetFlexShrink(YGNodeRef node, float flexShrink);
+YG_EXPORT float YGNodeStyleGetFlexShrink(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetFlexBasis(YGNodeRef node, float flexBasis);
+YG_EXPORT void YGNodeStyleSetFlexBasisPercent(YGNodeRef node, float flexBasis);
+YG_EXPORT void YGNodeStyleSetFlexBasisAuto(YGNodeRef node);
+YG_EXPORT YGValue YGNodeStyleGetFlexBasis(YGNodeConstRef node);
+
+YG_EXPORT void
+YGNodeStyleSetPosition(YGNodeRef node, YGEdge edge, float position);
+YG_EXPORT void
+YGNodeStyleSetPositionPercent(YGNodeRef node, YGEdge edge, float position);
+YG_EXPORT YGValue YGNodeStyleGetPosition(YGNodeConstRef node, YGEdge edge);
+YG_EXPORT void YGNodeStyleSetPositionAuto(YGNodeRef node, YGEdge edge);
+
+YG_EXPORT
+void YGNodeStyleSetMargin(YGNodeRef node, YGEdge edge, float margin);
+YG_EXPORT void
+YGNodeStyleSetMarginPercent(YGNodeRef node, YGEdge edge, float margin);
+YG_EXPORT void YGNodeStyleSetMarginAuto(YGNodeRef node, YGEdge edge);
+YG_EXPORT YGValue YGNodeStyleGetMargin(YGNodeConstRef node, YGEdge edge);
+
+YG_EXPORT void
+YGNodeStyleSetPadding(YGNodeRef node, YGEdge edge, float padding);
+YG_EXPORT void
+YGNodeStyleSetPaddingPercent(YGNodeRef node, YGEdge edge, float padding);
+YG_EXPORT YGValue YGNodeStyleGetPadding(YGNodeConstRef node, YGEdge edge);
+
+YG_EXPORT void YGNodeStyleSetBorder(YGNodeRef node, YGEdge edge, float border);
+YG_EXPORT float YGNodeStyleGetBorder(YGNodeConstRef node, YGEdge edge);
+
+YG_EXPORT void
+YGNodeStyleSetGap(YGNodeRef node, YGGutter gutter, float gapLength);
+YG_EXPORT void
+YGNodeStyleSetGapPercent(YGNodeRef node, YGGutter gutter, float gapLength);
+YG_EXPORT float YGNodeStyleGetGap(YGNodeConstRef node, YGGutter gutter);
+
+YG_EXPORT void YGNodeStyleSetBoxSizing(YGNodeRef node, YGBoxSizing boxSizing);
+YG_EXPORT YGBoxSizing YGNodeStyleGetBoxSizing(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetWidth(YGNodeRef node, float width);
+YG_EXPORT void YGNodeStyleSetWidthPercent(YGNodeRef node, float width);
+YG_EXPORT void YGNodeStyleSetWidthAuto(YGNodeRef node);
+YG_EXPORT YGValue YGNodeStyleGetWidth(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetHeight(YGNodeRef node, float height);
+YG_EXPORT void YGNodeStyleSetHeightPercent(YGNodeRef node, float height);
+YG_EXPORT void YGNodeStyleSetHeightAuto(YGNodeRef node);
+YG_EXPORT YGValue YGNodeStyleGetHeight(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetMinWidth(YGNodeRef node, float minWidth);
+YG_EXPORT void YGNodeStyleSetMinWidthPercent(YGNodeRef node, float minWidth);
+YG_EXPORT YGValue YGNodeStyleGetMinWidth(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetMinHeight(YGNodeRef node, float minHeight);
+YG_EXPORT void YGNodeStyleSetMinHeightPercent(YGNodeRef node, float minHeight);
+YG_EXPORT YGValue YGNodeStyleGetMinHeight(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetMaxWidth(YGNodeRef node, float maxWidth);
+YG_EXPORT void YGNodeStyleSetMaxWidthPercent(YGNodeRef node, float maxWidth);
+YG_EXPORT YGValue YGNodeStyleGetMaxWidth(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetMaxHeight(YGNodeRef node, float maxHeight);
+YG_EXPORT void YGNodeStyleSetMaxHeightPercent(YGNodeRef node, float maxHeight);
+YG_EXPORT YGValue YGNodeStyleGetMaxHeight(YGNodeConstRef node);
+
+YG_EXPORT void YGNodeStyleSetAspectRatio(YGNodeRef node, float aspectRatio);
+YG_EXPORT float YGNodeStyleGetAspectRatio(YGNodeConstRef node);
+
+YG_EXTERN_C_END

pythonnative/native/yoga/yoga/YGPixelGrid.cpp

@@ -0,0 +1,22 @@
+/*
+ * 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.
+ */
+
+#include <yoga/Yoga.h>
+
+#include <yoga/algorithm/PixelGrid.h>
+
+using namespace facebook;
+using namespace facebook::yoga;
+
+float YGRoundValueToPixelGrid(
+    const double value,
+    const double pointScaleFactor,
+    const bool forceCeil,
+    const bool forceFloor) {
+  return yoga::roundValueToPixelGrid(
+      value, pointScaleFactor, forceCeil, forceFloor);
+}

pythonnative/native/yoga/yoga/YGPixelGrid.h

@@ -0,0 +1,29 @@
+/*
+ * 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 <stdbool.h>
+
+#include <yoga/YGConfig.h>
+#include <yoga/YGEnums.h>
+#include <yoga/YGMacros.h>
+
+YG_EXTERN_C_BEGIN
+
+/**
+ * Rounds a point value to the nearest whole pixel, given a pointScaleFactor
+ * describing pixel density.
+ * @returns the rounded value in points
+ */
+YG_EXPORT float YGRoundValueToPixelGrid(
+    double value,
+    double pointScaleFactor,
+    bool forceCeil,
+    bool forceFloor);
+
+YG_EXTERN_C_END

pythonnative/native/yoga/yoga/YGValue.cpp

@@ -0,0 +1,20 @@
+/*
+ * 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.
+ */
+
+#include <yoga/YGValue.h>
+#include <yoga/numeric/Comparison.h>
+
+using namespace facebook;
+using namespace facebook::yoga;
+
+const YGValue YGValueZero = {0, YGUnitPoint};
+const YGValue YGValueUndefined = {YGUndefined, YGUnitUndefined};
+const YGValue YGValueAuto = {YGUndefined, YGUnitAuto};
+
+bool YGFloatIsUndefined(const float value) {
+  return yoga::isUndefined(value);
+}

pythonnative/native/yoga/yoga/YGValue.h

@@ -0,0 +1,84 @@
+/*
+ * 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 <stdbool.h>
+
+#include <yoga/YGEnums.h>
+#include <yoga/YGMacros.h>
+
+/**
+ * Float value to represent "undefined" in style values.
+ */
+#ifdef __cplusplus
+#include <limits>
+constexpr float YGUndefined = std::numeric_limits<float>::quiet_NaN();
+#else
+#include <math.h>
+#define YGUndefined NAN
+#endif
+
+YG_EXTERN_C_BEGIN
+
+/**
+ * Structure used to represent a dimension in a style.
+ */
+typedef struct YGValue {
+  float value;
+  YGUnit unit;
+} YGValue;
+
+/**
+ * Constant for a dimension of "auto".
+ */
+YG_EXPORT extern const YGValue YGValueAuto;
+
+/**
+ * Constant for a dimension which is not defined.
+ */
+YG_EXPORT extern const YGValue YGValueUndefined;
+
+/**
+ * Constant for a dimension that is zero-length.
+ */
+YG_EXPORT extern const YGValue YGValueZero;
+
+/**
+ * Whether a dimension represented as a float is defined.
+ */
+YG_EXPORT bool YGFloatIsUndefined(float value);
+
+YG_EXTERN_C_END
+
+// Equality operators for comparison of YGValue in C++
+#ifdef __cplusplus
+inline bool operator==(const YGValue& lhs, const YGValue& rhs) {
+  if (lhs.unit != rhs.unit) {
+    return false;
+  }
+
+  switch (lhs.unit) {
+    case YGUnitUndefined:
+    case YGUnitAuto:
+      return true;
+    case YGUnitPoint:
+    case YGUnitPercent:
+      return lhs.value == rhs.value;
+  }
+
+  return false;
+}
+
+inline bool operator!=(const YGValue& lhs, const YGValue& rhs) {
+  return !(lhs == rhs);
+}
+
+inline YGValue operator-(const YGValue& value) {
+  return {-value.value, value.unit};
+}
+#endif