pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/yoga/include/yoga/YGNodeLayout.h

@@ -0,0 +1,35 @@
+/*
+ * 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
+
+YG_EXPORT float YGNodeLayoutGetLeft(YGNodeConstRef node);
+YG_EXPORT float YGNodeLayoutGetTop(YGNodeConstRef node);
+YG_EXPORT float YGNodeLayoutGetRight(YGNodeConstRef node);
+YG_EXPORT float YGNodeLayoutGetBottom(YGNodeConstRef node);
+YG_EXPORT float YGNodeLayoutGetWidth(YGNodeConstRef node);
+YG_EXPORT float YGNodeLayoutGetHeight(YGNodeConstRef node);
+YG_EXPORT YGDirection YGNodeLayoutGetDirection(YGNodeConstRef node);
+YG_EXPORT bool YGNodeLayoutGetHadOverflow(YGNodeConstRef node);
+
+// Get the computed values for these nodes after performing layout. If they were
+// set using point values then the returned value will be the same as
+// YGNodeStyleGetXXX. However if they were set using a percentage value then the
+// returned value is the computed value used during layout.
+YG_EXPORT float YGNodeLayoutGetMargin(YGNodeConstRef node, YGEdge edge);
+YG_EXPORT float YGNodeLayoutGetBorder(YGNodeConstRef node, YGEdge edge);
+YG_EXPORT float YGNodeLayoutGetPadding(YGNodeConstRef node, YGEdge edge);
+
+YG_EXTERN_C_END

pythonnative/native/yoga/include/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/include/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/include/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

pythonnative/native/yoga/include/yoga/Yoga.h

@@ -0,0 +1,21 @@
+/*
+ * 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/Yoga.h>` includes all of Yoga's public headers.
+ */
+
+#include <yoga/YGConfig.h>
+#include <yoga/YGEnums.h>
+#include <yoga/YGMacros.h>
+#include <yoga/YGNode.h>
+#include <yoga/YGNodeLayout.h>
+#include <yoga/YGNodeStyle.h>
+#include <yoga/YGPixelGrid.h>
+#include <yoga/YGValue.h>

pythonnative/native/yoga/python.cpp

@@ -0,0 +1,16 @@
+// Python host binding for the same Yoga core used by mobile runtimes.
+#include <Python.h>
+#include <yoga/Yoga.h>
+extern "C" {
+typedef void (*PNMeasure)(YGNodeConstRef, float, int, float, int, float*, float*);
+static PNMeasure callback = nullptr;
+static YGSize measure(YGNodeConstRef node, float w, YGMeasureMode wm, float h, YGMeasureMode hm) {
+    float width = 0, height = 0;
+    callback(node, w, static_cast<int>(wm), h, static_cast<int>(hm), &width, &height);
+    return {width, height};
+}
+void pn_yoga_callback(PNMeasure fn) { callback = fn; }
+void pn_yoga_measure(YGNodeRef node, int enabled) { YGNodeSetMeasureFunc(node, enabled ? measure : nullptr); }
+static PyModuleDef module = {PyModuleDef_HEAD_INIT, "_yoga", "Yoga 3.2.1 host library", -1, nullptr};
+PyMODINIT_FUNC PyInit__yoga() { return PyModule_Create(&module); }
+}

pythonnative/native/yoga/style.cpp

@@ -0,0 +1,272 @@
+#include "include/PNStyle.h"
+#include <string>
+#include <cstdlib>
+#include <cmath>
+extern "C" bool PNYogaSetStyle(YGNodeRef node, const char* rawKey, const char* rawValue) {
+    std::string key(rawKey), value(rawValue);
+    bool percent = !value.empty() && value.back() == '%';
+    char* end = nullptr;
+    float number = std::strtof(rawValue, &end);
+    if (key == "direction") {
+        if (value == "inherit") { YGNodeStyleSetDirection(node, static_cast<YGDirection>(0)); return true; }
+        if (value == "ltr") { YGNodeStyleSetDirection(node, static_cast<YGDirection>(1)); return true; }
+        if (value == "rtl") { YGNodeStyleSetDirection(node, static_cast<YGDirection>(2)); return true; }
+        return false;
+    }
+    if (key == "flex_direction") {
+        if (value == "column") { YGNodeStyleSetFlexDirection(node, static_cast<YGFlexDirection>(0)); return true; }
+        if (value == "column_reverse") { YGNodeStyleSetFlexDirection(node, static_cast<YGFlexDirection>(1)); return true; }
+        if (value == "row") { YGNodeStyleSetFlexDirection(node, static_cast<YGFlexDirection>(2)); return true; }
+        if (value == "row_reverse") { YGNodeStyleSetFlexDirection(node, static_cast<YGFlexDirection>(3)); return true; }
+        return false;
+    }
+    if (key == "justify_content") {
+        if (value == "flex_start") { YGNodeStyleSetJustifyContent(node, static_cast<YGJustify>(0)); return true; }
+        if (value == "center") { YGNodeStyleSetJustifyContent(node, static_cast<YGJustify>(1)); return true; }
+        if (value == "flex_end") { YGNodeStyleSetJustifyContent(node, static_cast<YGJustify>(2)); return true; }
+        if (value == "space_between") { YGNodeStyleSetJustifyContent(node, static_cast<YGJustify>(3)); return true; }
+        if (value == "space_around") { YGNodeStyleSetJustifyContent(node, static_cast<YGJustify>(4)); return true; }
+        if (value == "space_evenly") { YGNodeStyleSetJustifyContent(node, static_cast<YGJustify>(5)); return true; }
+        return false;
+    }
+    if (key == "align_items") {
+        if (value == "auto") { YGNodeStyleSetAlignItems(node, static_cast<YGAlign>(0)); return true; }
+        if (value == "flex_start") { YGNodeStyleSetAlignItems(node, static_cast<YGAlign>(1)); return true; }
+        if (value == "center") { YGNodeStyleSetAlignItems(node, static_cast<YGAlign>(2)); return true; }
+        if (value == "flex_end") { YGNodeStyleSetAlignItems(node, static_cast<YGAlign>(3)); return true; }
+        if (value == "stretch") { YGNodeStyleSetAlignItems(node, static_cast<YGAlign>(4)); return true; }
+        if (value == "baseline") { YGNodeStyleSetAlignItems(node, static_cast<YGAlign>(5)); return true; }
+        if (value == "space_between") { YGNodeStyleSetAlignItems(node, static_cast<YGAlign>(6)); return true; }
+        if (value == "space_around") { YGNodeStyleSetAlignItems(node, static_cast<YGAlign>(7)); return true; }
+        if (value == "space_evenly") { YGNodeStyleSetAlignItems(node, static_cast<YGAlign>(8)); return true; }
+        return false;
+    }
+    if (key == "align_self") {
+        if (value == "auto") { YGNodeStyleSetAlignSelf(node, static_cast<YGAlign>(0)); return true; }
+        if (value == "flex_start") { YGNodeStyleSetAlignSelf(node, static_cast<YGAlign>(1)); return true; }
+        if (value == "center") { YGNodeStyleSetAlignSelf(node, static_cast<YGAlign>(2)); return true; }
+        if (value == "flex_end") { YGNodeStyleSetAlignSelf(node, static_cast<YGAlign>(3)); return true; }
+        if (value == "stretch") { YGNodeStyleSetAlignSelf(node, static_cast<YGAlign>(4)); return true; }
+        if (value == "baseline") { YGNodeStyleSetAlignSelf(node, static_cast<YGAlign>(5)); return true; }
+        if (value == "space_between") { YGNodeStyleSetAlignSelf(node, static_cast<YGAlign>(6)); return true; }
+        if (value == "space_around") { YGNodeStyleSetAlignSelf(node, static_cast<YGAlign>(7)); return true; }
+        if (value == "space_evenly") { YGNodeStyleSetAlignSelf(node, static_cast<YGAlign>(8)); return true; }
+        return false;
+    }
+    if (key == "align_content") {
+        if (value == "auto") { YGNodeStyleSetAlignContent(node, static_cast<YGAlign>(0)); return true; }
+        if (value == "flex_start") { YGNodeStyleSetAlignContent(node, static_cast<YGAlign>(1)); return true; }
+        if (value == "center") { YGNodeStyleSetAlignContent(node, static_cast<YGAlign>(2)); return true; }
+        if (value == "flex_end") { YGNodeStyleSetAlignContent(node, static_cast<YGAlign>(3)); return true; }
+        if (value == "stretch") { YGNodeStyleSetAlignContent(node, static_cast<YGAlign>(4)); return true; }
+        if (value == "baseline") { YGNodeStyleSetAlignContent(node, static_cast<YGAlign>(5)); return true; }
+        if (value == "space_between") { YGNodeStyleSetAlignContent(node, static_cast<YGAlign>(6)); return true; }
+        if (value == "space_around") { YGNodeStyleSetAlignContent(node, static_cast<YGAlign>(7)); return true; }
+        if (value == "space_evenly") { YGNodeStyleSetAlignContent(node, static_cast<YGAlign>(8)); return true; }
+        return false;
+    }
+    if (key == "position") {
+        if (value == "static") { YGNodeStyleSetPositionType(node, static_cast<YGPositionType>(0)); return true; }
+        if (value == "relative") { YGNodeStyleSetPositionType(node, static_cast<YGPositionType>(1)); return true; }
+        if (value == "absolute") { YGNodeStyleSetPositionType(node, static_cast<YGPositionType>(2)); return true; }
+        return false;
+    }
+    if (key == "flex_wrap") {
+        if (value == "nowrap") { YGNodeStyleSetFlexWrap(node, static_cast<YGWrap>(0)); return true; }
+        if (value == "wrap") { YGNodeStyleSetFlexWrap(node, static_cast<YGWrap>(1)); return true; }
+        if (value == "wrap_reverse") { YGNodeStyleSetFlexWrap(node, static_cast<YGWrap>(2)); return true; }
+        return false;
+    }
+    if (key == "display") {
+        if (value == "flex") { YGNodeStyleSetDisplay(node, static_cast<YGDisplay>(0)); return true; }
+        if (value == "none") { YGNodeStyleSetDisplay(node, static_cast<YGDisplay>(1)); return true; }
+        if (value == "contents") { YGNodeStyleSetDisplay(node, static_cast<YGDisplay>(2)); return true; }
+        return false;
+    }
+    if (key == "width") {
+        if (value == "auto") { YGNodeStyleSetWidthAuto(node); return true; }
+        if (percent) { YGNodeStyleSetWidthPercent(node, number); return true; }
+        YGNodeStyleSetWidth(node, number); return end != rawValue;
+    }
+    if (key == "height") {
+        if (value == "auto") { YGNodeStyleSetHeightAuto(node); return true; }
+        if (percent) { YGNodeStyleSetHeightPercent(node, number); return true; }
+        YGNodeStyleSetHeight(node, number); return end != rawValue;
+    }
+    if (key == "min_width") {
+        if (percent) { YGNodeStyleSetMinWidthPercent(node, number); return true; }
+        YGNodeStyleSetMinWidth(node, number); return end != rawValue;
+    }
+    if (key == "min_height") {
+        if (percent) { YGNodeStyleSetMinHeightPercent(node, number); return true; }
+        YGNodeStyleSetMinHeight(node, number); return end != rawValue;
+    }
+    if (key == "max_width") {
+        if (percent) { YGNodeStyleSetMaxWidthPercent(node, number); return true; }
+        YGNodeStyleSetMaxWidth(node, number); return end != rawValue;
+    }
+    if (key == "max_height") {
+        if (percent) { YGNodeStyleSetMaxHeightPercent(node, number); return true; }
+        YGNodeStyleSetMaxHeight(node, number); return end != rawValue;
+    }
+    if (key == "flex_basis") {
+        if (value == "auto") { YGNodeStyleSetFlexBasisAuto(node); return true; }
+        if (percent) { YGNodeStyleSetFlexBasisPercent(node, number); return true; }
+        YGNodeStyleSetFlexBasis(node, number); return end != rawValue;
+    }
+    if (key == "flex") {
+        YGNodeStyleSetFlex(node, number); return end != rawValue;
+    }
+    if (key == "flex_grow") {
+        YGNodeStyleSetFlexGrow(node, number); return end != rawValue;
+    }
+    if (key == "flex_shrink") {
+        YGNodeStyleSetFlexShrink(node, number); return end != rawValue;
+    }
+    if (key == "aspect_ratio") {
+        YGNodeStyleSetAspectRatio(node, number); return end != rawValue;
+    }
+    if (key == "margin_left") {
+        if (value == "auto") { YGNodeStyleSetMarginAuto(node, static_cast<YGEdge>(0)); return true; }
+        if (percent) { YGNodeStyleSetMarginPercent(node, static_cast<YGEdge>(0), number); return true; }
+        YGNodeStyleSetMargin(node, static_cast<YGEdge>(0), number); return end != rawValue;
+    }
+    if (key == "margin_top") {
+        if (value == "auto") { YGNodeStyleSetMarginAuto(node, static_cast<YGEdge>(1)); return true; }
+        if (percent) { YGNodeStyleSetMarginPercent(node, static_cast<YGEdge>(1), number); return true; }
+        YGNodeStyleSetMargin(node, static_cast<YGEdge>(1), number); return end != rawValue;
+    }
+    if (key == "margin_right") {
+        if (value == "auto") { YGNodeStyleSetMarginAuto(node, static_cast<YGEdge>(2)); return true; }
+        if (percent) { YGNodeStyleSetMarginPercent(node, static_cast<YGEdge>(2), number); return true; }
+        YGNodeStyleSetMargin(node, static_cast<YGEdge>(2), number); return end != rawValue;
+    }
+    if (key == "margin_bottom") {
+        if (value == "auto") { YGNodeStyleSetMarginAuto(node, static_cast<YGEdge>(3)); return true; }
+        if (percent) { YGNodeStyleSetMarginPercent(node, static_cast<YGEdge>(3), number); return true; }
+        YGNodeStyleSetMargin(node, static_cast<YGEdge>(3), number); return end != rawValue;
+    }
+    if (key == "margin_start") {
+        if (value == "auto") { YGNodeStyleSetMarginAuto(node, static_cast<YGEdge>(4)); return true; }
+        if (percent) { YGNodeStyleSetMarginPercent(node, static_cast<YGEdge>(4), number); return true; }
+        YGNodeStyleSetMargin(node, static_cast<YGEdge>(4), number); return end != rawValue;
+    }
+    if (key == "margin_end") {
+        if (value == "auto") { YGNodeStyleSetMarginAuto(node, static_cast<YGEdge>(5)); return true; }
+        if (percent) { YGNodeStyleSetMarginPercent(node, static_cast<YGEdge>(5), number); return true; }
+        YGNodeStyleSetMargin(node, static_cast<YGEdge>(5), number); return end != rawValue;
+    }
+    if (key == "margin_horizontal") {
+        if (value == "auto") { YGNodeStyleSetMarginAuto(node, static_cast<YGEdge>(6)); return true; }
+        if (percent) { YGNodeStyleSetMarginPercent(node, static_cast<YGEdge>(6), number); return true; }
+        YGNodeStyleSetMargin(node, static_cast<YGEdge>(6), number); return end != rawValue;
+    }
+    if (key == "margin_vertical") {
+        if (value == "auto") { YGNodeStyleSetMarginAuto(node, static_cast<YGEdge>(7)); return true; }
+        if (percent) { YGNodeStyleSetMarginPercent(node, static_cast<YGEdge>(7), number); return true; }
+        YGNodeStyleSetMargin(node, static_cast<YGEdge>(7), number); return end != rawValue;
+    }
+    if (key == "margin") {
+        if (value == "auto") { YGNodeStyleSetMarginAuto(node, static_cast<YGEdge>(8)); return true; }
+        if (percent) { YGNodeStyleSetMarginPercent(node, static_cast<YGEdge>(8), number); return true; }
+        YGNodeStyleSetMargin(node, static_cast<YGEdge>(8), number); return end != rawValue;
+    }
+    if (key == "padding_left") {
+        if (percent) { YGNodeStyleSetPaddingPercent(node, static_cast<YGEdge>(0), number); return true; }
+        YGNodeStyleSetPadding(node, static_cast<YGEdge>(0), number); return end != rawValue;
+    }
+    if (key == "padding_top") {
+        if (percent) { YGNodeStyleSetPaddingPercent(node, static_cast<YGEdge>(1), number); return true; }
+        YGNodeStyleSetPadding(node, static_cast<YGEdge>(1), number); return end != rawValue;
+    }
+    if (key == "padding_right") {
+        if (percent) { YGNodeStyleSetPaddingPercent(node, static_cast<YGEdge>(2), number); return true; }
+        YGNodeStyleSetPadding(node, static_cast<YGEdge>(2), number); return end != rawValue;
+    }
+    if (key == "padding_bottom") {
+        if (percent) { YGNodeStyleSetPaddingPercent(node, static_cast<YGEdge>(3), number); return true; }
+        YGNodeStyleSetPadding(node, static_cast<YGEdge>(3), number); return end != rawValue;
+    }
+    if (key == "padding_start") {
+        if (percent) { YGNodeStyleSetPaddingPercent(node, static_cast<YGEdge>(4), number); return true; }
+        YGNodeStyleSetPadding(node, static_cast<YGEdge>(4), number); return end != rawValue;
+    }
+    if (key == "padding_end") {
+        if (percent) { YGNodeStyleSetPaddingPercent(node, static_cast<YGEdge>(5), number); return true; }
+        YGNodeStyleSetPadding(node, static_cast<YGEdge>(5), number); return end != rawValue;
+    }
+    if (key == "padding_horizontal") {
+        if (percent) { YGNodeStyleSetPaddingPercent(node, static_cast<YGEdge>(6), number); return true; }
+        YGNodeStyleSetPadding(node, static_cast<YGEdge>(6), number); return end != rawValue;
+    }
+    if (key == "padding_vertical") {
+        if (percent) { YGNodeStyleSetPaddingPercent(node, static_cast<YGEdge>(7), number); return true; }
+        YGNodeStyleSetPadding(node, static_cast<YGEdge>(7), number); return end != rawValue;
+    }
+    if (key == "padding") {
+        if (percent) { YGNodeStyleSetPaddingPercent(node, static_cast<YGEdge>(8), number); return true; }
+        YGNodeStyleSetPadding(node, static_cast<YGEdge>(8), number); return end != rawValue;
+    }
+    if (key == "left") {
+        if (value == "auto") { YGNodeStyleSetPositionAuto(node, static_cast<YGEdge>(0)); return true; }
+        if (percent) { YGNodeStyleSetPositionPercent(node, static_cast<YGEdge>(0), number); return true; }
+        YGNodeStyleSetPosition(node, static_cast<YGEdge>(0), number); return end != rawValue;
+    }
+    if (key == "top") {
+        if (value == "auto") { YGNodeStyleSetPositionAuto(node, static_cast<YGEdge>(1)); return true; }
+        if (percent) { YGNodeStyleSetPositionPercent(node, static_cast<YGEdge>(1), number); return true; }
+        YGNodeStyleSetPosition(node, static_cast<YGEdge>(1), number); return end != rawValue;
+    }
+    if (key == "right") {
+        if (value == "auto") { YGNodeStyleSetPositionAuto(node, static_cast<YGEdge>(2)); return true; }
+        if (percent) { YGNodeStyleSetPositionPercent(node, static_cast<YGEdge>(2), number); return true; }
+        YGNodeStyleSetPosition(node, static_cast<YGEdge>(2), number); return end != rawValue;
+    }
+    if (key == "bottom") {
+        if (value == "auto") { YGNodeStyleSetPositionAuto(node, static_cast<YGEdge>(3)); return true; }
+        if (percent) { YGNodeStyleSetPositionPercent(node, static_cast<YGEdge>(3), number); return true; }
+        YGNodeStyleSetPosition(node, static_cast<YGEdge>(3), number); return end != rawValue;
+    }
+    if (key == "start") {
+        if (value == "auto") { YGNodeStyleSetPositionAuto(node, static_cast<YGEdge>(4)); return true; }
+        if (percent) { YGNodeStyleSetPositionPercent(node, static_cast<YGEdge>(4), number); return true; }
+        YGNodeStyleSetPosition(node, static_cast<YGEdge>(4), number); return end != rawValue;
+    }
+    if (key == "end") {
+        if (value == "auto") { YGNodeStyleSetPositionAuto(node, static_cast<YGEdge>(5)); return true; }
+        if (percent) { YGNodeStyleSetPositionPercent(node, static_cast<YGEdge>(5), number); return true; }
+        YGNodeStyleSetPosition(node, static_cast<YGEdge>(5), number); return end != rawValue;
+    }
+    if (key == "border_left_width") {
+        YGNodeStyleSetBorder(node, static_cast<YGEdge>(0), number); return end != rawValue;
+    }
+    if (key == "border_top_width") {
+        YGNodeStyleSetBorder(node, static_cast<YGEdge>(1), number); return end != rawValue;
+    }
+    if (key == "border_right_width") {
+        YGNodeStyleSetBorder(node, static_cast<YGEdge>(2), number); return end != rawValue;
+    }
+    if (key == "border_bottom_width") {
+        YGNodeStyleSetBorder(node, static_cast<YGEdge>(3), number); return end != rawValue;
+    }
+    if (key == "border_start_width") {
+        YGNodeStyleSetBorder(node, static_cast<YGEdge>(4), number); return end != rawValue;
+    }
+    if (key == "border_end_width") {
+        YGNodeStyleSetBorder(node, static_cast<YGEdge>(5), number); return end != rawValue;
+    }
+    if (key == "border_horizontal_width") {
+        YGNodeStyleSetBorder(node, static_cast<YGEdge>(6), number); return end != rawValue;
+    }
+    if (key == "border_vertical_width") {
+        YGNodeStyleSetBorder(node, static_cast<YGEdge>(7), number); return end != rawValue;
+    }
+    if (key == "border_width") {
+        YGNodeStyleSetBorder(node, static_cast<YGEdge>(8), number); return end != rawValue;
+    }
+    if (key == "gap") { if (percent) YGNodeStyleSetGapPercent(node, static_cast<YGGutter>(2), number); else YGNodeStyleSetGap(node, static_cast<YGGutter>(2), number); return true; }
+    if (key == "spacing") { if (percent) YGNodeStyleSetGapPercent(node, static_cast<YGGutter>(2), number); else YGNodeStyleSetGap(node, static_cast<YGGutter>(2), number); return true; }
+    if (key == "row_gap") { if (percent) YGNodeStyleSetGapPercent(node, static_cast<YGGutter>(1), number); else YGNodeStyleSetGap(node, static_cast<YGGutter>(1), number); return true; }
+    if (key == "column_gap") { if (percent) YGNodeStyleSetGapPercent(node, static_cast<YGGutter>(0), number); else YGNodeStyleSetGap(node, static_cast<YGGutter>(0), number); return true; }
+    return false;
+}

pythonnative/native/yoga/yoga/CMakeLists.txt

@@ -0,0 +1,41 @@
+# 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.
+
+
+cmake_minimum_required(VERSION 3.13...3.26)
+project(yogacore)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+if(TARGET yogacore)
+    return()
+endif()
+
+include(CheckIPOSupported)
+
+set(YOGA_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/..)
+include(${YOGA_ROOT}/cmake/project-defaults.cmake)
+
+
+file(GLOB SOURCES CONFIGURE_DEPENDS
+    ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/**/*.cpp)
+
+add_library(yogacore STATIC ${SOURCES})
+
+# Yoga conditionally uses <android/log> when building for Android
+if (ANDROID)
+    target_link_libraries(yogacore log)
+endif()
+
+check_ipo_supported(RESULT result)
+if(result)
+  set_target_properties(yogacore PROPERTIES
+    CMAKE_INTERPROCEDURAL_OPTIMIZATION true)
+endif()
+
+target_include_directories(yogacore
+    PUBLIC
+    $<BUILD_INTERFACE:${YOGA_ROOT}>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_PREFIX}/include/yoga>)