./set-version.py 3.2.1

Summary:
Pull Request resolved: https://github.com/facebook/yoga/pull/1766

While we added support for 16K pages for yoga through React Native,
the standalone version we upload to Maven Central wasn't handled.
This fixes it.

Reviewed By: NickGerleman

Differential Revision: D66975933

fbshipit-source-id: 36a8404e2f2a60a44b9a39e478b23d1829bc542e

.github/actions/clang-format/action.yml

@@ -0,0 +1,23 @@
+name: Clang Format
+inputs:
+  directory:
+    description: Directory to Lint
+    required: true
+  version:
+    description: LLVM version to use # Should be kept roughly in sync with arcanist
+    required: false
+    default: 12
+
+runs:
+  using: "composite"
+  steps:
+    - name: Install
+      shell: bash
+      run: sudo apt-get install -y clang-format-${{ inputs.version }}
+
+    - name: clang-format
+      working-directory: ${{ inputs.directory }}
+      shell: bash
+      env:
+        BASHOPTS: extglob:nullglob
+      run: clang-format-${{ inputs.version }} --dry-run --Werror **/*.{h,hh,hpp,c,cpp,cc,m,mm}

.github/actions/setup-cpp/action.yml

@@ -16,7 +16,6 @@ runs:
       if: ${{ inputs.toolchain == 'Clang' }}
       shell: bash
       run: |
-        sudo apt-get install -y libc++-dev libc++abi-dev
         echo "CC=/usr/bin/clang" >> $GITHUB_ENV
         echo "CXX=/usr/bin/clang++" >> $GITHUB_ENV
         echo "CXXFLAGS=-stdlib=libc++" >> $GITHUB_ENV

.github/workflows/publish-android-release.yml

@@ -24,7 +24,7 @@ jobs:
           ORG_GRADLE_PROJECT_SIGNING_PWD: ${{ secrets.ORG_GRADLE_PROJECT_SIGNING_PWD }}
 
       - name: Upload Build Artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: 'snapshot-artifacts'
           path: '~/.m2/repository/'

.github/workflows/publish-android-snashot.yml

@@ -23,7 +23,7 @@ jobs:
           ORG_GRADLE_PROJECT_USE_SNAPSHOT: true
 
       - name: Upload Build Artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: 'snapshot-artifacts'
           path: '~/.m2/repository/'

.github/workflows/validate-cpp.yml

@@ -97,3 +97,13 @@ jobs:
           cmake -S . -B build -G Ninja -D CMAKE_BUILD_TYPE=Release
           cmake --build build
         working-directory: capture
+
+  clang-format:
+    name: Format
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: clang-format
+        uses: ./.github/actions/clang-format

.github/workflows/validate-js.yml

@@ -110,7 +110,7 @@ jobs:
         run: yarn pack --filename yoga-layout.tar.gz
         working-directory: javascript
 
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v3
         with:
           name: npm-package
           path: javascript/yoga-layout.tar.gz

.gitignore

@@ -73,6 +73,3 @@ local.properties
 
 # Docusarus build
 .docusaurus
-
-# Android Studio
-.idea

Yoga.podspec

@@ -6,7 +6,7 @@
 
 Pod::Spec.new do |spec|
   spec.name = 'Yoga'
-  spec.version = '0.0.0'
+  spec.version = '3.2.1'
   spec.license =  { :type => 'MIT', :file => "LICENSE" }
   spec.homepage = 'https://yogalayout.dev/'
   spec.documentation_url = 'https://yogalayout.dev/docs'

build.gradle

@@ -9,7 +9,6 @@ plugins {
     id("com.android.library") version "8.7.1" apply false
     id("com.android.application") version "8.7.1" apply false
     id("io.github.gradle-nexus.publish-plugin") version "1.3.0"
-    id 'org.jetbrains.kotlin.android' version '2.1.20' apply false
 }
 
 allprojects {
@@ -35,8 +34,6 @@ nexusPublishing {
         sonatype {
             username.set(sonatypeUsername)
             password.set(sonatypePassword)
-            nexusUrl.set(uri("https://ossrh-staging-api.central.sonatype.com/service/local/"))
-            snapshotRepositoryUrl.set(uri("https://central.sonatype.com/repository/maven-snapshots/"))
         }
     }
 }

capture/NodeToString.cpp

@@ -225,17 +225,17 @@ static void serializeTreeImpl(
     appendEdges<&YGNodeStyleGetPosition>(
         j, "position", node, defaultNode.get());
 
-    appendYGValueIfNotDefault(
+    appendFloatIfNotDefault(
         j["style"],
         "gap",
         YGNodeStyleGetGap(node, YGGutterAll),
         YGNodeStyleGetGap(defaultNode.get(), YGGutterAll));
-    appendYGValueIfNotDefault(
+    appendFloatIfNotDefault(
         j["style"],
         "column-gap",
         YGNodeStyleGetGap(node, YGGutterColumn),
         YGNodeStyleGetGap(defaultNode.get(), YGGutterColumn));
-    appendYGValueIfNotDefault(
+    appendFloatIfNotDefault(
         j["style"],
         "row-gap",
         YGNodeStyleGetGap(node, YGGutterRow),

cmake/project-defaults.cmake

@@ -19,8 +19,8 @@ add_compile_options(
     # Enable warnings and warnings as errors
     /W4
     /WX
-    # Enable RTTI
+    # Disable RTTI
-    $<$<COMPILE_LANGUAGE:CXX>:/GR>
+    $<$<COMPILE_LANGUAGE:CXX>:/GR->
     # Use /O2 (Maximize Speed)
     $<$<CONFIG:RELEASE>:/O2>)
 
@@ -34,8 +34,8 @@ add_compile_options(
     # Enable warnings and warnings as errors
     -Wall
     -Werror
-    # Enable RTTI
+    # Disable RTTI
-    $<$<COMPILE_LANGUAGE:CXX>:-frtti>
+    $<$<COMPILE_LANGUAGE:CXX>:-fno-rtti>
     # Use -O2 (prioritize speed)
     $<$<CONFIG:RELEASE>:-O2>
     # Enable separate sections per function/data item

enums.py

@@ -8,15 +8,7 @@ import os
 
 ENUMS = {
     "Direction": ["Inherit", "LTR", "RTL"],
-    "Unit": [
+    "Unit": ["Undefined", "Point", "Percent", "Auto"],
-        "Undefined",
-        "Point",
-        "Percent",
-        "Auto",
-        "MaxContent",
-        "FitContent",
-        "Stretch",
-    ],
     "FlexDirection": ["Column", "ColumnReverse", "Row", "RowReverse"],
     "Justify": [
         "FlexStart",

gentest/fixtures/YGAlignItemsTest.html

@@ -240,14 +240,3 @@
   <div style="position:relative; width:50px; height:50px;">
   </div>
 </div>
-
-<div id="align_items_non_stretch_s526008"
-  style="flex-direction: column; width: 400px; height: 400px;">
-  <div style="flex-direction: row;">
-    <div style="flex-direction: column; align-items: flex-start;">
-      <div>
-        <div style="width: 0; height: 10px;"></div>
-      </div>
-    </div>
-  </div>
-</div>

gentest/fixtures/YGIntrinsicSizeTest.html

@@ -157,31 +157,6 @@
     </div>
 </div>
 
-<div id="contains_inner_text_max_width_max_height_column" style="width:2000px; align-items: flex-start;">
-    <div style="max-width: 50px;">
-        Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eleifasd et tortor ac auctor. Integer at
-        volutpat
-        libero, sed elementum dui interdum id. Aliquam consectetur massa vel neque aliquet, quis consequat risus
-        fringilla. Fusce rhoncus ipsum tempor eros aliquam, vel tempus metus ullamcorper. Nam at nulla sed tellus
-        vestibulum fringilla vel sit amet ligula. Proin velit lectus, euismod sit amet quam vel ultricies dolor,
-        vitae
-        finibus lorem ipsum. Pellentesque molestie at mi sit amet dictum. Donec vehicula lacinia felis sit amet
-        consectetur. Praesent sodales enim sapien, sed varius ipsum pellentesque vel. Aenean eu mi eu justo
-        tincidunt
-        finibus vel sit amet ipsum. Sed bibasdum purus vel ipsum sagittis, quis fermentum dolor lobortis. Etiam
-        vulputate eleifasd lectus vel varius.
-        Phasellus imperdiet lectus sit amet ipsum egestas, ut bibasdum ipsum malesuada. Vestibulum ante ipsum primis
-        in
-        faucibus orci luctus et ultrices posuere cubilia Curae; Sed mollis eros sit amet elit porttitor, vel
-        venenatis
-        turpis venenatis. Nulla tempus tortor at eros efficitur, sit amet dapibus ipsum malesuada. Ut at mauris sed
-        nunc
-        malesuada convallis. Duis id sem vel magna varius eleifasd vel at est. Donec eget orci a ipsum tempor
-        lobortis.
-        Sed at consectetur ipsum.
-    </div>
-</div>
-
 
 <div id="contains_inner_text_max_width" style="width:2000px;height:2000px;align-items: flex-start;">
     <div style="flex-direction:row;max-width:100px">
@@ -244,325 +219,3 @@
         Sed at consectetur ipsum.
     </div>
 </div>
-
-<div id="max_content_width" style="flex-direction: row; width:max-content; flex-wrap: wrap;">
-    <div style="width: 50px; height: 50px;">
-    </div>
-    <div style="width: 100px; height: 50px;">
-    </div>
-    <div style="width: 25px; height: 50px;">
-    </div>
-</div>
-
-<div data-disabled="true" id="fit_content_width" style="width: 90px;">
-    <div style="flex-direction: row; width: fit-content; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 100px; height: 50px;">
-        </div>
-        <div style="width: 25px; height: 50px;">
-        </div>
-    </div>
-</div>
-
-<div id="stretch_width" style="width: 500px;">
-    <div style="flex-direction: row; width: -webkit-fill-available; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 100px; height: 50px;">
-        </div>
-        <div style="width: 25px; height: 50px;">
-        </div>
-    </div>
-</div>
-
-<div id="max_content_height" style="height:max-content; flex-wrap: wrap;">
-    <div style="width: 50px; height: 50px;">
-    </div>
-    <div style="width: 50px; height: 100px;">
-    </div>
-    <div style="width: 50px; height: 25px;">
-    </div>
-</div>
-
-<div data-disabled="true" id="fit_content_height" style="height: 90px; ">
-    <div style="height: fit-content; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 50px; height: 100px;">
-        </div>
-        <div style="width: 50px; height: 25px;">
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="stretch_height" style="height: 500px;">
-    <div style="height: -webkit-fill-available; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 50px; height: 100px;">
-        </div>
-        <div style="width: 50px; height: 25px;">
-        </div>
-    </div>
-</div>
-
-<div id="max_content_flex_basis_column" style="flex-basis: max-content; flex-wrap: wrap;">
-    <div style="width: 50px; height: 50px;">
-    </div>
-    <div style="width: 50px; height: 100px;">
-    </div>
-    <div style="width: 50px; height: 25px;">
-    </div>
-</div>
-
-<div data-disabled="true" id="fit_content_flex_basis_column" style="height: 90px;">
-    <div style="flex-basis: fit-content; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 50px; height: 100px;">
-        </div>
-        <div style="width: 50px; height: 25px;">
-        </div>
-    </div>
-</div>
-
-<div id="stretch_flex_basis_column" style="height: 500px;">
-    <div style="flex-basis: -webkit-fill-available; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 50px; height: 100px;">
-        </div>
-        <div style="width: 50px; height: 25px;">
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="max_content_flex_basis_row" style="flex-direction: row; flex-basis: max-content; flex-wrap: wrap;">
-    <div style="width: 50px; height: 50px;">
-    </div>
-    <div style="width: 100px; height: 500px;">
-    </div>
-    <div style="width: 25px; height: 50px;">
-    </div>
-</div>
-
-<div data-disabled="true" id="fit_content_flex_basis_row" style="width: 90px;">
-    <div style="flex-direction: row; flex-basis: fit-content; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 100px; height: 50px;">
-        </div>
-        <div style="width: 25px; height: 50px;">
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="stretch_flex_basis_row" style="width: 500px;">
-    <div style="flex-direction: row; flex-basis: -webkit-fill-available; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 100px; height: 50px;">
-        </div>
-        <div style="width: 25px; height: 50px;">
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="max_content_max_width"
-    style="flex-direction: row; max-width:max-content; width: 200px; flex-wrap: wrap;">
-    <div style="width: 50px; height: 50px;">
-    </div>
-    <div style="width: 100px; height: 50px;">
-    </div>
-    <div style="width: 25px; height: 50px;">
-    </div>
-</div>
-
-<div data-disabled="true" id="fit_content_max_width" style="width: 90px;">
-    <div style="flex-direction: row; max-width: fit-content; width: 110px; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 100px; height: 50px;">
-        </div>
-        <div style="width: 25px; height: 50px;">
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="stretch_max_width" style="width: 500px;">
-    <div style="flex-direction: row; max-width: -webkit-fill-available; width: 600px; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 100px; height: 50px;">
-        </div>
-        <div style="width: 25px; height: 50px;">
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="max_content_min_width"
-    style="flex-direction: row; min-width:max-content; width: 100px; flex-wrap: wrap;">
-    <div style="width: 50px; height: 50px;">
-    </div>
-    <div style="width: 100px; height: 50px;">
-    </div>
-    <div style="width: 25px; height: 50px;">
-    </div>
-</div>
-
-<div data-disabled="true" id="fit_content_min_width" style="width: 90px;">
-    <div style="flex-direction: row; min-width: fit-content; width: 90px; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 100px; height: 50px;">
-        </div>
-        <div style="width: 25px; height: 50px;">
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="stretch_min_width" style="width: 500px;">
-    <div style="flex-direction: row; min-width: -webkit-fill-available; width: 400px; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 100px; height: 50px;">
-        </div>
-        <div style="width: 25px; height: 50px;">
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="max_content_max_height" style="max-height:max-content; height: 200px; flex-wrap: wrap;">
-    <div style="width: 50px; height: 50px;">
-    </div>
-    <div style="width: 50px; height: 100px;">
-    </div>
-    <div style="width: 50px; height: 25px;">
-    </div>
-</div>
-
-<div data-disabled="true" id="fit_content_max_height" style="height: 90px;">
-    <div style="max-height: fit-content; height: 110px; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 50px; height: 100px;">
-        </div>
-        <div style="width: 50px; height: 25px;">
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="stretch_max_height" style="height: 500px;">
-    <div style="max-height: -webkit-fill-available; flex-wrap: wrap; height: 600px;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 50px; height: 100px;">
-        </div>
-        <div style="width: 50px; height: 25px;">
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="max_content_min_height" style="min-height:max-content; height: 100px; flex-wrap: wrap;">
-    <div style="width: 50px; height: 50px;">
-    </div>
-    <div style="width: 50px; height: 100px;">
-    </div>
-    <div style="width: 50px; height: 25px;">
-    </div>
-</div>
-
-<div data-disabled="true" id="fit_content_min_height" style="height: 90px;">
-    <div style="min-height: fit-content; height: 90px; flex-wrap: wrap;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 50px; height: 100px;">
-        </div>
-        <div style="width: 50px; height: 25px;">
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="stretch_min_height" style="height: 500px;">
-    <div style="min-height: -webkit-fill-available; flex-wrap: wrap; height: 400px;">
-        <div style="width: 50px; height: 50px;">
-        </div>
-        <div style="width: 50px; height: 100px;">
-        </div>
-        <div style="width: 50px; height: 25px;">
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="text_max_content_width" style="width: 200px">
-    <div style="width: max-content;">
-        <div style="flex-direction:row;">
-            Lorem ipsum sdafhasdfkjlasdhlkajsfhasldkfhasdlkahsdflkjasdhflaksdfasdlkjhasdlfjahsdfljkasdhalsdfhas dolor sit amet
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="text_stretch_width" style="width: 200px">
-    <div style="width: -webkit-fill-available;">
-        <div style="flex-direction:row;">
-            Lorem ipsum dolor sit amet
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="text_fit_content_width" style="width: 200px">
-    <div style="width: fit-content;">
-        <div style="flex-direction:row;">
-            Lorem ipsum sdafhasdfkjlasdhlkajsfhasldkfhasdlkahsdflkjasdhflaksdfasdlkjhasdlfjahsdfljkasdhalsdfhas dolor sit amet
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="text_max_content_min_width" style="width: 200px">
-    <div style="min-width: max-content; width: 200px;">
-        <div style="flex-direction:row;">
-            Lorem ipsum sdafhasdfkjlasdhlkajsfhasldkfhasdlkahsdflkjasdhflaksdfasdlkjhasdlfjahsdfljkasdhalsdfhas dolor sit amet
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="text_stretch_min_width" style="width: 200px">
-    <div style="min-width: -webkit-fill-available; width: 100px;">
-        <div style="flex-direction:row;">
-            Lorem ipsum dolor sit amet
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" data-disabled="true" id="text_fit_content_min_width" style="width: 200px">
-    <div style="min-width: fit-content; width: 300px">
-        <div style="flex-direction:row;">
-            Lorem ipsum sdafhasdfkjlasdhlkajsfhasldkfhasdlkahsdflkjasdhflaksdfasdlkjhasdlfjahsdfljkasdhalsdfhas dolor sit amet
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="text_max_content_max_width" style="width: 200px">
-    <div style="max-width: max-content; width: 2000px;">
-        <div style="flex-direction:row;">
-            Lorem ipsum sdafhasdfkjlasdhlkajsfhasldkfhasdlkahsdflkjasdhflaksdfasdlkjhasdlfjahsdfljkasdhalsdfhas dolor sit amet
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="text_stretch_max_width" style="width: 200px">
-    <div style="max-width: -webkit-fill-available; width: 300px;">
-        <div style="flex-direction:row;">
-            Lorem ipsum dolor sit amet
-        </div>
-    </div>
-</div>
-
-<div data-disabled="true" id="text_fit_content_max_width" style="width: 200px">
-    <div style="max-width: fit-content; width: 1000px">
-        <div style="flex-direction:row;">
-            Lorem ipsum sdafhasdfkjlasdhlkajsfhasldkfhasdlkahsdflkjasdhflaksdfasdlkjhasdlfjahsdfljkasdhalsdfhas dolor sit amet
-        </div>
-    </div>
-</div>

gentest/gentest-cpp.js

@@ -17,25 +17,13 @@ function toFunctionNameCpp(value) {
     return 'Percent';
   } else if (value.indexOf('Auto') >= 0) {
     return 'Auto';
-  } else if (value.indexOf('MaxContent') >= 0) {
-    return 'MaxContent';
-  } else if (value.indexOf('FitContent') >= 0) {
-    return 'FitContent';
-  } else if (value.indexOf('Stretch') >= 0) {
-    return 'Stretch';
   }
-
   return '';
 }
 
 function keywordFunctionCpp(functionPrefix, nodeName, value) {
   const functionSuffix = toFunctionNameCpp(value);
-  if (
+  if (functionSuffix == 'Auto') {
-    functionSuffix == 'Auto' ||
-    functionSuffix == 'MaxContent' ||
-    functionSuffix == 'FitContent' ||
-    functionSuffix == 'Stretch'
-  ) {
     return functionPrefix + functionSuffix + '(' + nodeName + ');';
   } else {
     return (
@@ -175,10 +163,6 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, {
   YGDisplayContents: {value: 'YGDisplayContents'},
   YGAuto: {value: 'YGAuto'},
 
-  YGMaxContent: {value: 'MaxContent'},
-  YGFitContent: {value: 'FitContent'},
-  YGStretch: {value: 'Stretch'},
-
   YGNodeCalculateLayout: {
     value: function (node, dir, _experiments) {
       this.push(
@@ -398,25 +382,57 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, {
 
   YGNodeStyleSetMaxHeight: {
     value: function (nodeName, value) {
-      this.push(keywordFunctionCpp('YGNodeStyleSetMaxHeight', nodeName, value));
+      this.push(
+        'YGNodeStyleSetMaxHeight' +
+          toFunctionNameCpp(value) +
+          '(' +
+          nodeName +
+          ', ' +
+          toValueCpp(value) +
+          ');',
+      );
     },
   },
 
   YGNodeStyleSetMaxWidth: {
     value: function (nodeName, value) {
-      this.push(keywordFunctionCpp('YGNodeStyleSetMaxWidth', nodeName, value));
+      this.push(
+        'YGNodeStyleSetMaxWidth' +
+          toFunctionNameCpp(value) +
+          '(' +
+          nodeName +
+          ', ' +
+          toValueCpp(value) +
+          ');',
+      );
     },
   },
 
   YGNodeStyleSetMinHeight: {
     value: function (nodeName, value) {
-      this.push(keywordFunctionCpp('YGNodeStyleSetMinHeight', nodeName, value));
+      this.push(
+        'YGNodeStyleSetMinHeight' +
+          toFunctionNameCpp(value) +
+          '(' +
+          nodeName +
+          ', ' +
+          toValueCpp(value) +
+          ');',
+      );
     },
   },
 
   YGNodeStyleSetMinWidth: {
     value: function (nodeName, value) {
-      this.push(keywordFunctionCpp('YGNodeStyleSetMinWidth', nodeName, value));
+      this.push(
+        'YGNodeStyleSetMinWidth' +
+          toFunctionNameCpp(value) +
+          '(' +
+          nodeName +
+          ', ' +
+          toValueCpp(value) +
+          ');',
+      );
     },
   },
 
@@ -502,7 +518,7 @@ CPPEmitter.prototype = Object.create(Emitter.prototype, {
   },
 
   YGNodeSetMeasureFunc: {
-    value: function (nodeName, innerText, _) {
+    value: function (nodeName, innerText) {
       this.push(`YGNodeSetContext(${nodeName}, (void*)"${innerText}");`);
       this.push(
         `YGNodeSetMeasureFunc(${nodeName}, &facebook::yoga::test::IntrinsicSizeMeasure);`,

gentest/gentest-java.js

@@ -17,24 +17,13 @@ function toMethodName(value) {
     return 'Percent';
   } else if (value.indexOf('AUTO') >= 0) {
     return 'Auto';
-  } else if (value.indexOf('MAX_CONTENT') >= 0) {
-    return 'MaxContent';
-  } else if (value.indexOf('FIT_CONTENT') >= 0) {
-    return 'FitContent';
-  } else if (value.indexOf('STRETCH') >= 0) {
-    return 'Stretch';
   }
   return '';
 }
 
 function keywordMethod(methodPrefix, nodeName, value) {
   const methodSuffix = toMethodName(value);
-  if (
+  if (methodSuffix == 'Auto') {
-    methodSuffix == 'Auto' ||
-    methodSuffix == 'MaxContent' ||
-    methodSuffix == 'FitContent' ||
-    methodSuffix == 'Stretch'
-  ) {
     return nodeName + '.' + methodPrefix + methodSuffix + '();';
   } else {
     return (
@@ -216,10 +205,6 @@ JavaEmitter.prototype = Object.create(Emitter.prototype, {
   YGBoxSizingBorderBox: {value: 'YogaBoxSizing.BORDER_BOX'},
   YGBoxSizingContentBox: {value: 'YogaBoxSizing.CONTENT_BOX'},
 
-  YGMaxContent: {value: 'MAX_CONTENT'},
-  YGFitContent: {value: 'FIT_CONTENT'},
-  YGStretch: {value: 'STRETCH'},
-
   YGNodeCalculateLayout: {
     value: function (node, dir, _experiments) {
       this.push(node + '.setDirection(' + dir + ');');
@@ -375,25 +360,53 @@ JavaEmitter.prototype = Object.create(Emitter.prototype, {
 
   YGNodeStyleSetMaxHeight: {
     value: function (nodeName, value) {
-      this.push(keywordMethod('setMaxHeight', nodeName, value));
+      this.push(
+        nodeName +
+          '.setMaxHeight' +
+          toMethodName(value) +
+          '(' +
+          toValueJava(value) +
+          'f);',
+      );
     },
   },
 
   YGNodeStyleSetMaxWidth: {
     value: function (nodeName, value) {
-      this.push(keywordMethod('setMaxWidth', nodeName, value));
+      this.push(
+        nodeName +
+          '.setMaxWidth' +
+          toMethodName(value) +
+          '(' +
+          toValueJava(value) +
+          'f);',
+      );
     },
   },
 
   YGNodeStyleSetMinHeight: {
     value: function (nodeName, value) {
-      this.push(keywordMethod('setMinHeight', nodeName, value));
+      this.push(
+        nodeName +
+          '.setMinHeight' +
+          toMethodName(value) +
+          '(' +
+          toValueJava(value) +
+          'f);',
+      );
     },
   },
 
   YGNodeStyleSetMinWidth: {
     value: function (nodeName, value) {
-      this.push(keywordMethod('setMinWidth', nodeName, value));
+      this.push(
+        nodeName +
+          '.setMinWidth' +
+          toMethodName(value) +
+          '(' +
+          toValueJava(value) +
+          'f);',
+      );
     },
   },
 
@@ -467,7 +480,7 @@ JavaEmitter.prototype = Object.create(Emitter.prototype, {
   },
 
   YGNodeSetMeasureFunc: {
-    value: function (nodeName, innerText, _) {
+    value: function (nodeName, innerText) {
       this.push(`${nodeName}.setData("${innerText}");`);
       this.push(
         `${nodeName}.setMeasureFunction(new TestUtils.intrinsicMeasureFunction());`,

gentest/gentest-javascript.js

@@ -15,9 +15,6 @@ function toValueJavascript(value) {
   if (value.match(/^[0-9.e+-]+px$/i)) return parseFloat(value);
   if (value.match(/^[0-9.e+-]+%/i)) return JSON.stringify(value);
   if (value == 'Yoga.AUTO') return '"auto"';
-  if (value == 'max-content') return '"max-content"';
-  if (value == 'fit-content') return '"fit-content"';
-  if (value == 'stretch') return '"stretch"';
   return value;
 }
 
@@ -179,10 +176,6 @@ JavascriptEmitter.prototype = Object.create(Emitter.prototype, {
   YGBoxSizingBorderBox: {value: 'BoxSizing.BorderBox'},
   YGBoxSizingContentBox: {value: 'BoxSizing.ContentBox'},
 
-  YGMaxContent: {value: 'max-content'},
-  YGFitContent: {value: 'fit-content'},
-  YGStretch: {value: 'stretch'},
-
   YGNodeCalculateLayout: {
     value: function (node, dir, _experiments) {
       this.push(node + '.calculateLayout(undefined, undefined, ' + dir + ');');
@@ -429,11 +422,9 @@ JavascriptEmitter.prototype = Object.create(Emitter.prototype, {
   },
 
   YGNodeSetMeasureFunc: {
-    value: function (nodeName, innerText, flexDirection) {
+    value: function (nodeName, innerText) {
       this.push(
-        `${nodeName}.setMeasureFunc(instrinsicSizeMeasureFunc.bind({text: "${innerText}", flexDirection: ${toValueJavascript(
+        `${nodeName}.setMeasureFunc(instrinsicSizeMeasureFunc.bind("${innerText}"));`,
-          flexDirection,
-        )}}));`,
       );
     },
   },

gentest/gentest.js

@@ -533,11 +533,7 @@ function setupTestTree(
   }
 
   if (node.innerText && node.children.length === 0) {
-    e.YGNodeSetMeasureFunc(
+    e.YGNodeSetMeasureFunc(nodeName, node.innerText);
-      nodeName,
-      node.innerText,
-      flexDirectionValue(e, node.style['flex-direction']),
-    );
   }
 
   for (let i = 0; i < node.children.length; i++) {
@@ -658,13 +654,6 @@ function pointValue(e, value) {
       return e.YGAuto;
     case 'undefined':
       return e.YGUndefined;
-    case 'max-content':
-      return e.YGMaxContent;
-    case 'fit-content':
-      return e.YGFitContent;
-    case 'stretch':
-    case '-webkit-fill-available':
-      return e.YGStretch;
     default:
       return value;
   }

gradle.properties

@@ -11,4 +11,4 @@ android.useAndroidX=true
 
 org.gradle.jvmargs=-Xmx1536M
 
-VERSION_NAME=0.0.0
+VERSION_NAME=3.2.1

gradle/gradle-enterprise.gradle.kts.sample

@@ -0,0 +1,17 @@
+/*
+ * 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.
+ */
+
+// You can use this script to configure the gradleEnterprise{} block in your build.
+// You need to rename this file to ./gradle/gradle-enterprise.gradle.kts in order for
+// this to be processed.
+extensions.getByName("gradleEnterprise").withGroovyBuilder {
+    setProperty("server", "https://your-gradle-enterprise-instance.example.com")
+    getProperty("buildScan").withGroovyBuilder {
+        "publishAlways"()
+        "tag"(if(System.getenv("CI") != null) "CI" else "Local")
+    }
+}

gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-all.zip
 networkTimeout=10000
-validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -15,8 +15,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# SPDX-License-Identifier: Apache-2.0
-#
 
 ##############################################################################
 #
@@ -57,7 +55,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -85,8 +83,7 @@ done
 # This is normally unused
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -133,13 +130,10 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    if ! command -v java >/dev/null 2>&1
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-    then
-        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
-    fi
 fi
 
 # Increase the maximum file descriptors if we can.
@@ -147,7 +141,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
         # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
+        # shellcheck disable=SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
@@ -155,7 +149,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
       '' | soft) :;; #(
       *)
         # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
+        # shellcheck disable=SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -204,11 +198,11 @@ fi
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
-# Collect all arguments for the java command:
+# Collect all arguments for the java command;
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     and any embedded shellness will be escaped.
+#     shell script including quotes and variable substitutions, so put them in
-#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     double quotes to make sure that they get re-expanded; and
-#     treated as '${Hostname}' itself on the command line.
+#   * put everything else in single quotes, so that it's not re-expanded.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \

gradlew.bat

@@ -13,8 +13,6 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
-@rem SPDX-License-Identifier: Apache-2.0
-@rem
 
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
@@ -45,11 +43,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo. 1>&2
+echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo. 1>&2
+echo.
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation. 1>&2
+echo location of your Java installation.
 
 goto fail
 
@@ -59,11 +57,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo. 1>&2
+echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo. 1>&2
+echo.
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation. 1>&2
+echo location of your Java installation.
 
 goto fail
 

java/AndroidManifest.xml

@@ -1,17 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-
-<!--
-  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.
--->
-
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.facebook.yoga"
-          android:versionCode="1"
-          android:versionName="1.0"
-    >
 
     <application/>
 

java/build.gradle.kts

@@ -9,7 +9,6 @@ plugins {
   id("com.android.library")
   id("maven-publish")
   id("signing")
-  id("org.jetbrains.kotlin.android")
 }
 
 group = "com.facebook.yoga"
@@ -49,8 +48,6 @@ android {
     }
   }
 
-  kotlinOptions { jvmTarget = "1.8" }
-
   publishing {
     multipleVariants {
       withSourcesJar()
@@ -63,7 +60,6 @@ android {
 dependencies {
   implementation("com.google.code.findbugs:jsr305:3.0.2")
   implementation("com.facebook.soloader:soloader:0.10.5")
-  implementation("androidx.core:core-ktx:1.16.0")
   testImplementation("junit:junit:4.12")
 }
 

java/com/facebook/yoga/YogaConstants.java

@@ -0,0 +1,25 @@
+/*
+ * 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.yoga;
+
+public class YogaConstants {
+
+  public static final float UNDEFINED = Float.NaN;
+
+  public static boolean isUndefined(float value) {
+    return Float.compare(value, UNDEFINED) == 0;
+  }
+
+  public static boolean isUndefined(YogaValue value) {
+    return value.unit == YogaUnit.UNDEFINED;
+  }
+
+  public static float getUndefined() {
+    return UNDEFINED;
+  }
+}

java/com/facebook/yoga/YogaConstants.kt

@@ -1,18 +0,0 @@
-/*
- * 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.yoga
-
-public object YogaConstants {
-  @JvmField public val UNDEFINED: Float = Float.NaN
-
-  @JvmStatic public fun isUndefined(value: Float): Boolean = value.compareTo(UNDEFINED) == 0
-
-  @JvmStatic public fun isUndefined(value: YogaValue): Boolean = value.unit == YogaUnit.UNDEFINED
-
-  @JvmStatic public fun getUndefined(): Float = UNDEFINED
-}

java/com/facebook/yoga/YogaNative.java

@@ -74,9 +74,6 @@ 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);
@@ -94,43 +91,25 @@ 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 long jni_YGNodeStyleGetGapJNI(long nativePointer, int gutter);
+  static native float 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);

java/com/facebook/yoga/YogaNode.java

@@ -0,0 +1,237 @@
+/*
+ * 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.yoga;
+
+import javax.annotation.Nullable;
+
+public abstract class YogaNode implements YogaProps {
+
+  /** The interface the {@link #getData()} object can optionally implement. */
+  public interface Inputs {
+
+    /** Requests the data object to disable mutations of its inputs. */
+    void freeze(final YogaNode node, final @Nullable YogaNode parent);
+  }
+
+  public abstract void reset();
+
+  public abstract int getChildCount();
+
+  public abstract YogaNode getChildAt(int i);
+
+  public abstract void addChildAt(YogaNode child, int i);
+
+  public abstract void setIsReferenceBaseline(boolean isReferenceBaseline);
+
+  public abstract boolean isReferenceBaseline();
+
+  public abstract YogaNode removeChildAt(int i);
+
+  /**
+   * @returns the {@link YogaNode} that owns this {@link YogaNode}. The owner is used to identify
+   *     the YogaTree that a {@link YogaNode} belongs to. This method will return the parent of the
+   *     {@link YogaNode} when the {@link YogaNode} only belongs to one YogaTree or null when the
+   *     {@link YogaNode} is shared between two or more YogaTrees.
+   */
+  @Nullable
+  public abstract YogaNode getOwner();
+
+  /** @deprecated Use #getOwner() instead. This will be removed in the next version. */
+  @Deprecated
+  @Nullable
+  public abstract YogaNode getParent();
+
+  public abstract int indexOf(YogaNode child);
+
+  public abstract void calculateLayout(float width, float height);
+
+  public abstract boolean hasNewLayout();
+
+  public abstract void dirty();
+
+  public abstract boolean isDirty();
+
+  public abstract void copyStyle(YogaNode srcNode);
+
+  public abstract void markLayoutSeen();
+
+  public abstract YogaDirection getStyleDirection();
+
+  public abstract void setDirection(YogaDirection direction);
+
+  public abstract YogaFlexDirection getFlexDirection();
+
+  public abstract void setFlexDirection(YogaFlexDirection flexDirection);
+
+  public abstract YogaJustify getJustifyContent();
+
+  public abstract void setJustifyContent(YogaJustify justifyContent);
+
+  public abstract YogaAlign getAlignItems();
+
+  public abstract void setAlignItems(YogaAlign alignItems);
+
+  public abstract YogaAlign getAlignSelf();
+
+  public abstract void setAlignSelf(YogaAlign alignSelf);
+
+  public abstract YogaAlign getAlignContent();
+
+  public abstract void setAlignContent(YogaAlign alignContent);
+
+  public abstract YogaPositionType getPositionType();
+
+  public abstract void setPositionType(YogaPositionType positionType);
+
+  public abstract YogaBoxSizing getBoxSizing();
+
+  public abstract void setBoxSizing(YogaBoxSizing boxSizing);
+
+  public abstract YogaWrap getWrap();
+
+  public abstract void setWrap(YogaWrap flexWrap);
+
+  public abstract YogaOverflow getOverflow();
+
+  public abstract void setOverflow(YogaOverflow overflow);
+
+  public abstract YogaDisplay getDisplay();
+
+  public abstract void setDisplay(YogaDisplay display);
+
+  public abstract float getFlex();
+
+  public abstract void setFlex(float flex);
+
+  public abstract float getFlexGrow();
+
+  public abstract void setFlexGrow(float flexGrow);
+
+  public abstract float getFlexShrink();
+
+  public abstract void setFlexShrink(float flexShrink);
+
+  public abstract YogaValue getFlexBasis();
+
+  public abstract void setFlexBasis(float flexBasis);
+
+  public abstract void setFlexBasisPercent(float percent);
+
+  public abstract void setFlexBasisAuto();
+
+  public abstract YogaValue getMargin(YogaEdge edge);
+
+  public abstract void setMargin(YogaEdge edge, float margin);
+
+  public abstract void setMarginPercent(YogaEdge edge, float percent);
+
+  public abstract void setMarginAuto(YogaEdge edge);
+
+  public abstract YogaValue getPadding(YogaEdge edge);
+
+  public abstract void setPadding(YogaEdge edge, float padding);
+
+  public abstract void setPaddingPercent(YogaEdge edge, float percent);
+
+  public abstract float getBorder(YogaEdge edge);
+
+  public abstract void setBorder(YogaEdge edge, float border);
+
+  public abstract YogaValue getPosition(YogaEdge edge);
+
+  public abstract void setPosition(YogaEdge edge, float position);
+
+  public abstract void setPositionPercent(YogaEdge edge, float percent);
+
+  public abstract void setPositionAuto(YogaEdge edge);
+
+  public abstract YogaValue getWidth();
+
+  public abstract void setWidth(float width);
+
+  public abstract void setWidthPercent(float percent);
+
+  public abstract void setWidthAuto();
+
+  public abstract YogaValue getHeight();
+
+  public abstract void setHeight(float height);
+
+  public abstract void setHeightPercent(float percent);
+
+  public abstract void setHeightAuto();
+
+  public abstract YogaValue getMinWidth();
+
+  public abstract void setMinWidth(float minWidth);
+
+  public abstract void setMinWidthPercent(float percent);
+
+  public abstract YogaValue getMinHeight();
+
+  public abstract void setMinHeight(float minHeight);
+
+  public abstract void setMinHeightPercent(float percent);
+
+  public abstract YogaValue getMaxWidth();
+
+  public abstract void setMaxWidth(float maxWidth);
+
+  public abstract void setMaxWidthPercent(float percent);
+
+  public abstract YogaValue getMaxHeight();
+
+  public abstract void setMaxHeight(float maxheight);
+
+  public abstract void setMaxHeightPercent(float percent);
+
+  public abstract float getAspectRatio();
+
+  public abstract void setAspectRatio(float aspectRatio);
+
+  public abstract float getGap(YogaGutter gutter);
+
+  public abstract void setGap(YogaGutter gutter, float gapLength);
+
+  public abstract void setGapPercent(YogaGutter gutter, float gapLength);
+
+  public abstract float getLayoutX();
+
+  public abstract float getLayoutY();
+
+  public abstract float getLayoutWidth();
+
+  public abstract float getLayoutHeight();
+
+  public abstract float getLayoutMargin(YogaEdge edge);
+
+  public abstract float getLayoutPadding(YogaEdge edge);
+
+  public abstract float getLayoutBorder(YogaEdge edge);
+
+  public abstract YogaDirection getLayoutDirection();
+
+  public abstract void setMeasureFunction(YogaMeasureFunction measureFunction);
+
+  public abstract void setBaselineFunction(YogaBaselineFunction baselineFunction);
+
+  public abstract boolean isMeasureDefined();
+
+  public abstract boolean isBaselineDefined();
+
+  public abstract void setData(Object data);
+
+  @Nullable
+  public abstract Object getData();
+
+  public abstract YogaNode cloneWithoutChildren();
+
+  public abstract YogaNode cloneWithChildren();
+
+  public abstract void setAlwaysFormsContainingBlock(boolean alwaysFormsContainingBlock);
+}

java/com/facebook/yoga/YogaNode.kt

@@ -1,273 +0,0 @@
-/*
- * 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.yoga
-
-public abstract class YogaNode : YogaProps {
-  /** The interface the [getData] object can optionally implement. */
-  public fun interface Inputs {
-    /** Requests the data object to disable mutations of its inputs. */
-    public fun freeze(node: YogaNode, parent: YogaNode?)
-  }
-
-  public abstract fun reset()
-
-  public abstract fun getChildCount(): Int
-
-  public abstract fun getChildAt(i: Int): YogaNode
-
-  public abstract fun addChildAt(child: YogaNode, i: Int)
-
-  abstract override fun setIsReferenceBaseline(isReferenceBaseline: Boolean)
-
-  public abstract fun isReferenceBaseline(): Boolean
-
-  public abstract fun removeChildAt(i: Int): YogaNode
-
-  /**
-   * @returns the [YogaNode] that owns this [YogaNode]. The owner is used to identify the YogaTree
-   *   that a [YogaNode] belongs to. This method will return the parent of the [YogaNode] when the
-   *   [YogaNode] only belongs to one YogaTree or null when the [YogaNode] is shared between two or
-   *   more YogaTrees.
-   */
-  public abstract fun getOwner(): YogaNode?
-
-  @Deprecated(
-      "Use getOwner() instead. This will be removed in the next version. ",
-      replaceWith = ReplaceWith("getOwner()"))
-  public abstract fun getParent(): YogaNode?
-
-  public abstract fun indexOf(child: YogaNode): Int
-
-  public abstract fun calculateLayout(width: Float, height: Float)
-
-  public abstract fun hasNewLayout(): Boolean
-
-  public abstract fun dirty()
-
-  public abstract fun isDirty(): Boolean
-
-  public abstract fun copyStyle(srcNode: YogaNode)
-
-  public abstract fun markLayoutSeen()
-
-  abstract override fun getStyleDirection(): YogaDirection
-
-  abstract override fun setDirection(direction: YogaDirection)
-
-  abstract override fun getFlexDirection(): YogaFlexDirection
-
-  abstract override fun setFlexDirection(flexDirection: YogaFlexDirection)
-
-  abstract override fun getJustifyContent(): YogaJustify
-
-  abstract override fun setJustifyContent(justifyContent: YogaJustify)
-
-  abstract override fun getAlignItems(): YogaAlign
-
-  abstract override fun setAlignItems(alignItems: YogaAlign)
-
-  abstract override fun getAlignSelf(): YogaAlign
-
-  abstract override fun setAlignSelf(alignSelf: YogaAlign)
-
-  abstract override fun getAlignContent(): YogaAlign
-
-  abstract override fun setAlignContent(alignContent: YogaAlign)
-
-  abstract override fun getPositionType(): YogaPositionType
-
-  abstract override fun setPositionType(positionType: YogaPositionType)
-
-  abstract override fun getBoxSizing(): YogaBoxSizing
-
-  abstract override fun setBoxSizing(boxSizing: YogaBoxSizing)
-
-  public abstract fun getWrap(): YogaWrap
-
-  abstract override fun setWrap(flexWrap: YogaWrap)
-
-  public abstract fun getOverflow(): YogaOverflow
-
-  public abstract fun setOverflow(overflow: YogaOverflow)
-
-  public abstract fun getDisplay(): YogaDisplay
-
-  public abstract fun setDisplay(display: YogaDisplay)
-
-  public abstract fun getFlex(): Float
-
-  abstract override fun setFlex(flex: Float)
-
-  abstract override fun getFlexGrow(): Float
-
-  abstract override fun setFlexGrow(flexGrow: Float)
-
-  abstract override fun getFlexShrink(): Float
-
-  abstract override fun setFlexShrink(flexShrink: Float)
-
-  abstract override fun getFlexBasis(): YogaValue
-
-  abstract override fun setFlexBasis(flexBasis: Float)
-
-  abstract override fun setFlexBasisPercent(percent: Float)
-
-  abstract override fun setFlexBasisAuto()
-
-  abstract override fun setFlexBasisMaxContent()
-
-  abstract override fun setFlexBasisFitContent()
-
-  abstract override fun setFlexBasisStretch()
-
-  abstract override fun getMargin(edge: YogaEdge): YogaValue
-
-  abstract override fun setMargin(edge: YogaEdge, margin: Float)
-
-  abstract override fun setMarginPercent(edge: YogaEdge, percent: Float)
-
-  abstract override fun setMarginAuto(edge: YogaEdge)
-
-  abstract override fun getPadding(edge: YogaEdge): YogaValue
-
-  abstract override fun setPadding(edge: YogaEdge, padding: Float)
-
-  abstract override fun setPaddingPercent(edge: YogaEdge, percent: Float)
-
-  abstract override fun getBorder(edge: YogaEdge): Float
-
-  abstract override fun setBorder(edge: YogaEdge, border: Float)
-
-  abstract override fun getPosition(edge: YogaEdge): YogaValue
-
-  abstract override fun setPosition(edge: YogaEdge, position: Float)
-
-  abstract override fun setPositionPercent(edge: YogaEdge, percent: Float)
-
-  public abstract fun setPositionAuto(edge: YogaEdge)
-
-  abstract override fun getWidth(): YogaValue
-
-  abstract override fun setWidth(width: Float)
-
-  abstract override fun setWidthPercent(percent: Float)
-
-  abstract override fun setWidthAuto()
-
-  abstract override fun setWidthMaxContent()
-
-  abstract override fun setWidthFitContent()
-
-  abstract override fun setWidthStretch()
-
-  abstract override fun getHeight(): YogaValue
-
-  abstract override fun setHeight(height: Float)
-
-  abstract override fun setHeightPercent(percent: Float)
-
-  abstract override fun setHeightAuto()
-
-  abstract override fun setHeightMaxContent()
-
-  abstract override fun setHeightFitContent()
-
-  abstract override fun setHeightStretch()
-
-  abstract override fun getMinWidth(): YogaValue
-
-  abstract override fun setMinWidth(minWidth: Float)
-
-  abstract override fun setMinWidthPercent(percent: Float)
-
-  abstract override fun setMinWidthMaxContent()
-
-  abstract override fun setMinWidthFitContent()
-
-  abstract override fun setMinWidthStretch()
-
-  abstract override fun getMinHeight(): YogaValue
-
-  abstract override fun setMinHeight(minHeight: Float)
-
-  abstract override fun setMinHeightPercent(percent: Float)
-
-  abstract override fun setMinHeightMaxContent()
-
-  abstract override fun setMinHeightFitContent()
-
-  abstract override fun setMinHeightStretch()
-
-  abstract override fun getMaxWidth(): YogaValue
-
-  abstract override fun setMaxWidth(maxWidth: Float)
-
-  abstract override fun setMaxWidthPercent(percent: Float)
-
-  abstract override fun setMaxWidthMaxContent()
-
-  abstract override fun setMaxWidthFitContent()
-
-  abstract override fun setMaxWidthStretch()
-
-  abstract override fun getMaxHeight(): YogaValue
-
-  abstract override fun setMaxHeight(maxheight: Float)
-
-  abstract override fun setMaxHeightPercent(percent: Float)
-
-  abstract override fun setMaxHeightMaxContent()
-
-  abstract override fun setMaxHeightFitContent()
-
-  abstract override fun setMaxHeightStretch()
-
-  abstract override fun getAspectRatio(): Float
-
-  abstract override fun setAspectRatio(aspectRatio: Float)
-
-  public abstract fun getGap(gutter: YogaGutter): YogaValue
-
-  public abstract fun setGap(gutter: YogaGutter, gapLength: Float)
-
-  public abstract fun setGapPercent(gutter: YogaGutter, gapLength: Float)
-
-  public abstract fun getLayoutX(): Float
-
-  public abstract fun getLayoutY(): Float
-
-  public abstract fun getLayoutWidth(): Float
-
-  public abstract fun getLayoutHeight(): Float
-
-  public abstract fun getLayoutMargin(edge: YogaEdge): Float
-
-  public abstract fun getLayoutPadding(edge: YogaEdge): Float
-
-  public abstract fun getLayoutBorder(edge: YogaEdge): Float
-
-  public abstract fun getLayoutDirection(): YogaDirection
-
-  abstract override fun setMeasureFunction(measureFunction: YogaMeasureFunction)
-
-  abstract override fun setBaselineFunction(baselineFunction: YogaBaselineFunction)
-
-  public abstract fun isMeasureDefined(): Boolean
-
-  public abstract fun isBaselineDefined(): Boolean
-
-  public abstract fun setData(data: Any)
-
-  public abstract fun getData(): Any?
-
-  public abstract fun cloneWithoutChildren(): YogaNode
-
-  public abstract fun cloneWithChildren(): YogaNode
-
-  public abstract fun setAlwaysFormsContainingBlock(alwaysFormsContainingBlock: Boolean)
-}

java/com/facebook/yoga/YogaNodeJNIBase.java

@@ -373,18 +373,6 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetFlexBasisAutoJNI(mNativePointer);
   }
 
-  public void setFlexBasisMaxContent() {
-    YogaNative.jni_YGNodeStyleSetFlexBasisMaxContentJNI(mNativePointer);
-  }
-
-  public void setFlexBasisFitContent() {
-    YogaNative.jni_YGNodeStyleSetFlexBasisFitContentJNI(mNativePointer);
-  }
-
-  public void setFlexBasisStretch() {
-    YogaNative.jni_YGNodeStyleSetFlexBasisStretchJNI(mNativePointer);
-  }
-
   public YogaValue getMargin(YogaEdge edge) {
     return valueFromLong(YogaNative.jni_YGNodeStyleGetMarginJNI(mNativePointer, edge.intValue()));
   }
@@ -453,18 +441,6 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetWidthAutoJNI(mNativePointer);
   }
 
-  public void setWidthMaxContent() {
-    YogaNative.jni_YGNodeStyleSetWidthMaxContentJNI(mNativePointer);
-  }
-
-  public void setWidthFitContent() {
-    YogaNative.jni_YGNodeStyleSetWidthFitContentJNI(mNativePointer);
-  }
-
-  public void setWidthStretch() {
-    YogaNative.jni_YGNodeStyleSetWidthStretchJNI(mNativePointer);
-  }
-
   public YogaValue getHeight() {
     return valueFromLong(YogaNative.jni_YGNodeStyleGetHeightJNI(mNativePointer));
   }
@@ -481,18 +457,6 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetHeightAutoJNI(mNativePointer);
   }
 
-  public void setHeightMaxContent() {
-    YogaNative.jni_YGNodeStyleSetHeightMaxContentJNI(mNativePointer);
-  }
-
-  public void setHeightFitContent() {
-    YogaNative.jni_YGNodeStyleSetHeightFitContentJNI(mNativePointer);
-  }
-
-  public void setHeightStretch() {
-    YogaNative.jni_YGNodeStyleSetHeightStretchJNI(mNativePointer);
-  }
-
   public YogaValue getMinWidth() {
     return valueFromLong(YogaNative.jni_YGNodeStyleGetMinWidthJNI(mNativePointer));
   }
@@ -505,18 +469,6 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetMinWidthPercentJNI(mNativePointer, percent);
   }
 
-  public void setMinWidthMaxContent() {
-    YogaNative.jni_YGNodeStyleSetMinWidthMaxContentJNI(mNativePointer);
-  }
-
-  public void setMinWidthFitContent() {
-    YogaNative.jni_YGNodeStyleSetMinWidthFitContentJNI(mNativePointer);
-  }
-
-  public void setMinWidthStretch() {
-    YogaNative.jni_YGNodeStyleSetMinWidthStretchJNI(mNativePointer);
-  }
-
   public YogaValue getMinHeight() {
     return valueFromLong(YogaNative.jni_YGNodeStyleGetMinHeightJNI(mNativePointer));
   }
@@ -529,18 +481,6 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetMinHeightPercentJNI(mNativePointer, percent);
   }
 
-  public void setMinHeightMaxContent() {
-    YogaNative.jni_YGNodeStyleSetMinHeightMaxContentJNI(mNativePointer);
-  }
-
-  public void setMinHeightFitContent() {
-    YogaNative.jni_YGNodeStyleSetMinHeightFitContentJNI(mNativePointer);
-  }
-
-  public void setMinHeightStretch() {
-    YogaNative.jni_YGNodeStyleSetMinHeightStretchJNI(mNativePointer);
-  }
-
   public YogaValue getMaxWidth() {
     return valueFromLong(YogaNative.jni_YGNodeStyleGetMaxWidthJNI(mNativePointer));
   }
@@ -553,18 +493,6 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetMaxWidthPercentJNI(mNativePointer, percent);
   }
 
-  public void setMaxWidthMaxContent() {
-    YogaNative.jni_YGNodeStyleSetMaxWidthMaxContentJNI(mNativePointer);
-  }
-
-  public void setMaxWidthFitContent() {
-    YogaNative.jni_YGNodeStyleSetMaxWidthFitContentJNI(mNativePointer);
-  }
-
-  public void setMaxWidthStretch() {
-    YogaNative.jni_YGNodeStyleSetMaxWidthStretchJNI(mNativePointer);
-  }
-
   public YogaValue getMaxHeight() {
     return valueFromLong(YogaNative.jni_YGNodeStyleGetMaxHeightJNI(mNativePointer));
   }
@@ -577,18 +505,6 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetMaxHeightPercentJNI(mNativePointer, percent);
   }
 
-  public void setMaxHeightMaxContent() {
-    YogaNative.jni_YGNodeStyleSetMaxHeightMaxContentJNI(mNativePointer);
-  }
-
-  public void setMaxHeightFitContent() {
-    YogaNative.jni_YGNodeStyleSetMaxHeightFitContentJNI(mNativePointer);
-  }
-
-  public void setMaxHeightStretch() {
-    YogaNative.jni_YGNodeStyleSetMaxHeightStretchJNI(mNativePointer);
-  }
-
   public float getAspectRatio() {
     return YogaNative.jni_YGNodeStyleGetAspectRatioJNI(mNativePointer);
   }
@@ -811,8 +727,8 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
   }
 
   @Override
-  public YogaValue getGap(YogaGutter gutter) {
+  public float getGap(YogaGutter gutter) {
-    return valueFromLong(YogaNative.jni_YGNodeStyleGetGapJNI(mNativePointer, gutter.intValue()));
+    return YogaNative.jni_YGNodeStyleGetGapJNI(mNativePointer, gutter.intValue());
   }
 
   @Override

java/com/facebook/yoga/YogaProps.java

@@ -15,33 +15,15 @@ public interface YogaProps {
 
   void setWidthPercent(float percent);
 
-  void setWidthAuto();
-
-  void setWidthMaxContent();
-
-  void setWidthFitContent();
-
-  void setWidthStretch();
-
   void setMinWidth(float minWidth);
 
   void setMinWidthPercent(float percent);
 
-  void setMinWidthMaxContent();
-
-  void setMinWidthFitContent();
-
-  void setMinWidthStretch();
-
   void setMaxWidth(float maxWidth);
 
   void setMaxWidthPercent(float percent);
 
-  void setMaxWidthMaxContent();
+  void setWidthAuto();
-
-  void setMaxWidthFitContent();
-
-  void setMaxWidthStretch();
 
   /* Height properties */
 
@@ -49,33 +31,15 @@ public interface YogaProps {
 
   void setHeightPercent(float percent);
 
-  void setHeightAuto();
-
-  void setHeightMaxContent();
-
-  void setHeightFitContent();
-
-  void setHeightStretch();
-
   void setMinHeight(float minHeight);
 
   void setMinHeightPercent(float percent);
 
-  void setMinHeightMaxContent();
-
-  void setMinHeightFitContent();
-
-  void setMinHeightStretch();
-
   void setMaxHeight(float maxHeight);
 
   void setMaxHeightPercent(float percent);
 
-  void setMaxHeightMaxContent();
+  void setHeightAuto();
-
-  void setMaxHeightFitContent();
-
-  void setMaxHeightStretch();
 
   /* Margin properties */
 
@@ -117,12 +81,6 @@ public interface YogaProps {
 
   void setFlexBasis(float flexBasis);
 
-  void setFlexBasisMaxContent();
-
-  void setFlexBasisFitContent();
-
-  void setFlexBasisStretch();
-
   void setFlexDirection(YogaFlexDirection direction);
 
   void setFlexGrow(float flexGrow);

java/com/facebook/yoga/YogaUnit.java

@@ -13,10 +13,7 @@ public enum YogaUnit {
   UNDEFINED(0),
   POINT(1),
   PERCENT(2),
-  AUTO(3),
+  AUTO(3);
-  MAX_CONTENT(4),
-  FIT_CONTENT(5),
-  STRETCH(6);
 
   private final int mIntValue;
 
@@ -34,9 +31,6 @@ public enum YogaUnit {
       case 1: return POINT;
       case 2: return PERCENT;
       case 3: return AUTO;
-      case 4: return MAX_CONTENT;
-      case 5: return FIT_CONTENT;
-      case 6: return STRETCH;
       default: throw new IllegalArgumentException("Unknown enum value: " + value);
     }
   }

java/jni/YGJNIVanilla.cpp

@@ -429,28 +429,6 @@ static void jni_YGNodeCopyStyleJNI(
     YGNodeStyleSet##name##Auto(_jlong2YGNodeRef(nativePointer)); \
   }
 
-#define YG_NODE_JNI_STYLE_UNIT_PROP_AUTO_INTRINSIC(name) \
-  YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(name)                 \
-  YG_NODE_JNI_STYLE_UNIT_INTRINSIC(name)
-
-#define YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(name) \
-  YG_NODE_JNI_STYLE_UNIT_PROP(name)                 \
-  YG_NODE_JNI_STYLE_UNIT_INTRINSIC(name)
-
-#define YG_NODE_JNI_STYLE_UNIT_INTRINSIC(name)                         \
-  static void jni_YGNodeStyleSet##name##MaxContentJNI(                 \
-      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {         \
-    YGNodeStyleSet##name##MaxContent(_jlong2YGNodeRef(nativePointer)); \
-  }                                                                    \
-  static void jni_YGNodeStyleSet##name##FitContentJNI(                 \
-      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {         \
-    YGNodeStyleSet##name##FitContent(_jlong2YGNodeRef(nativePointer)); \
-  }                                                                    \
-  static void jni_YGNodeStyleSet##name##StretchJNI(                    \
-      JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {         \
-    YGNodeStyleSet##name##Stretch(_jlong2YGNodeRef(nativePointer));    \
-  }
-
 #define YG_NODE_JNI_STYLE_EDGE_UNIT_PROP(name)                            \
   static jlong jni_YGNodeStyleGet##name##JNI(                             \
       JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer, jint edge) { \
@@ -505,13 +483,13 @@ YG_NODE_JNI_STYLE_PROP(jfloat, float, Flex);
 YG_NODE_JNI_STYLE_PROP(jfloat, float, FlexGrow);
 YG_NODE_JNI_STYLE_PROP(jfloat, float, FlexShrink);
 
-YG_NODE_JNI_STYLE_UNIT_PROP_AUTO_INTRINSIC(FlexBasis);
+YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(FlexBasis);
-YG_NODE_JNI_STYLE_UNIT_PROP_AUTO_INTRINSIC(Width);
+YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(Width);
-YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(MinWidth);
+YG_NODE_JNI_STYLE_UNIT_PROP(MinWidth);
-YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(MaxWidth);
+YG_NODE_JNI_STYLE_UNIT_PROP(MaxWidth);
-YG_NODE_JNI_STYLE_UNIT_PROP_AUTO_INTRINSIC(Height);
+YG_NODE_JNI_STYLE_UNIT_PROP_AUTO(Height);
-YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(MinHeight);
+YG_NODE_JNI_STYLE_UNIT_PROP(MinHeight);
-YG_NODE_JNI_STYLE_UNIT_PROP_INTRINSIC(MaxHeight);
+YG_NODE_JNI_STYLE_UNIT_PROP(MaxHeight);
 
 YG_NODE_JNI_STYLE_EDGE_UNIT_PROP_AUTO(Position);
 
@@ -725,13 +703,13 @@ jni_YGNodeCloneJNI(JNIEnv* /*env*/, jobject /*obj*/, jlong nativePointer) {
   return reinterpret_cast<jlong>(clonedYogaNode);
 }
 
-static jlong jni_YGNodeStyleGetGapJNI(
+static jfloat jni_YGNodeStyleGetGapJNI(
     JNIEnv* /*env*/,
     jobject /*obj*/,
     jlong nativePointer,
     jint gutter) {
-  return YogaValue::asJavaLong(YGNodeStyleGetGap(
+  return (jfloat)YGNodeStyleGetGap(
-      _jlong2YGNodeRef(nativePointer), static_cast<YGGutter>(gutter)));
+      _jlong2YGNodeRef(nativePointer), static_cast<YGGutter>(gutter));
 }
 
 static void jni_YGNodeStyleSetGapJNI(
@@ -892,15 +870,6 @@ static JNINativeMethod methods[] = {
     {"jni_YGNodeStyleSetFlexBasisAutoJNI",
      "(J)V",
      (void*)jni_YGNodeStyleSetFlexBasisAutoJNI},
-    {"jni_YGNodeStyleSetFlexBasisMaxContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetFlexBasisMaxContentJNI},
-    {"jni_YGNodeStyleSetFlexBasisFitContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetFlexBasisFitContentJNI},
-    {"jni_YGNodeStyleSetFlexBasisStretchJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetFlexBasisStretchJNI},
     {"jni_YGNodeStyleGetMarginJNI",
      "(JI)J",
      (void*)jni_YGNodeStyleGetMarginJNI},
@@ -948,15 +917,6 @@ static JNINativeMethod methods[] = {
     {"jni_YGNodeStyleSetWidthAutoJNI",
      "(J)V",
      (void*)jni_YGNodeStyleSetWidthAutoJNI},
-    {"jni_YGNodeStyleSetWidthMaxContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetWidthMaxContentJNI},
-    {"jni_YGNodeStyleSetWidthFitContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetWidthFitContentJNI},
-    {"jni_YGNodeStyleSetWidthStretchJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetWidthStretchJNI},
     {"jni_YGNodeStyleGetHeightJNI", "(J)J", (void*)jni_YGNodeStyleGetHeightJNI},
     {"jni_YGNodeStyleSetHeightJNI",
      "(JF)V",
@@ -967,15 +927,6 @@ static JNINativeMethod methods[] = {
     {"jni_YGNodeStyleSetHeightAutoJNI",
      "(J)V",
      (void*)jni_YGNodeStyleSetHeightAutoJNI},
-    {"jni_YGNodeStyleSetHeightMaxContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetHeightMaxContentJNI},
-    {"jni_YGNodeStyleSetHeightFitContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetHeightFitContentJNI},
-    {"jni_YGNodeStyleSetHeightStretchJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetHeightStretchJNI},
     {"jni_YGNodeStyleGetMinWidthJNI",
      "(J)J",
      (void*)jni_YGNodeStyleGetMinWidthJNI},
@@ -985,15 +936,6 @@ static JNINativeMethod methods[] = {
     {"jni_YGNodeStyleSetMinWidthPercentJNI",
      "(JF)V",
      (void*)jni_YGNodeStyleSetMinWidthPercentJNI},
-    {"jni_YGNodeStyleSetMinWidthMaxContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetMinWidthMaxContentJNI},
-    {"jni_YGNodeStyleSetMinWidthFitContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetMinWidthFitContentJNI},
-    {"jni_YGNodeStyleSetMinWidthStretchJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetMinWidthStretchJNI},
     {"jni_YGNodeStyleGetMinHeightJNI",
      "(J)J",
      (void*)jni_YGNodeStyleGetMinHeightJNI},
@@ -1003,15 +945,6 @@ static JNINativeMethod methods[] = {
     {"jni_YGNodeStyleSetMinHeightPercentJNI",
      "(JF)V",
      (void*)jni_YGNodeStyleSetMinHeightPercentJNI},
-    {"jni_YGNodeStyleSetMinHeightMaxContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetMinHeightMaxContentJNI},
-    {"jni_YGNodeStyleSetMinHeightFitContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetMinHeightFitContentJNI},
-    {"jni_YGNodeStyleSetMinHeightStretchJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetMinHeightStretchJNI},
     {"jni_YGNodeStyleGetMaxWidthJNI",
      "(J)J",
      (void*)jni_YGNodeStyleGetMaxWidthJNI},
@@ -1021,15 +954,6 @@ static JNINativeMethod methods[] = {
     {"jni_YGNodeStyleSetMaxWidthPercentJNI",
      "(JF)V",
      (void*)jni_YGNodeStyleSetMaxWidthPercentJNI},
-    {"jni_YGNodeStyleSetMaxWidthMaxContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetMaxWidthMaxContentJNI},
-    {"jni_YGNodeStyleSetMaxWidthFitContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetMaxWidthFitContentJNI},
-    {"jni_YGNodeStyleSetMaxWidthStretchJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetMaxWidthStretchJNI},
     {"jni_YGNodeStyleGetMaxHeightJNI",
      "(J)J",
      (void*)jni_YGNodeStyleGetMaxHeightJNI},
@@ -1039,15 +963,6 @@ static JNINativeMethod methods[] = {
     {"jni_YGNodeStyleSetMaxHeightPercentJNI",
      "(JF)V",
      (void*)jni_YGNodeStyleSetMaxHeightPercentJNI},
-    {"jni_YGNodeStyleSetMaxHeightMaxContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetMaxHeightMaxContentJNI},
-    {"jni_YGNodeStyleSetMaxHeightFitContentJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetMaxHeightFitContentJNI},
-    {"jni_YGNodeStyleSetMaxHeightStretchJNI",
-     "(J)V",
-     (void*)jni_YGNodeStyleSetMaxHeightStretchJNI},
     {"jni_YGNodeStyleGetAspectRatioJNI",
      "(J)F",
      (void*)jni_YGNodeStyleGetAspectRatioJNI},
@@ -1057,7 +972,7 @@ static JNINativeMethod methods[] = {
     {"jni_YGNodeSetHasMeasureFuncJNI",
      "(JZ)V",
      (void*)jni_YGNodeSetHasMeasureFuncJNI},
-    {"jni_YGNodeStyleGetGapJNI", "(JI)J", (void*)jni_YGNodeStyleGetGapJNI},
+    {"jni_YGNodeStyleGetGapJNI", "(JI)F", (void*)jni_YGNodeStyleGetGapJNI},
     {"jni_YGNodeStyleSetGapJNI", "(JIF)V", (void*)jni_YGNodeStyleSetGapJNI},
     {"jni_YGNodeStyleSetGapPercentJNI",
      "(JIF)V",

java/tests/com/facebook/yoga/utils/TestUtils.java

@@ -11,7 +11,6 @@ import com.facebook.yoga.YogaMeasureMode;
 import com.facebook.yoga.YogaMeasureOutput;
 import com.facebook.yoga.YogaMeasureFunction;
 import com.facebook.yoga.YogaNode;
-import com.facebook.yoga.YogaFlexDirection;
 
 public class TestUtils {
 
@@ -44,13 +43,9 @@ public class TestUtils {
       } else if (heightMode == YogaMeasureMode.AT_MOST) {
         measuredHeight =
             Math.min(
-                caclulateHeight(text, node.getFlexDirection() == YogaFlexDirection.COLUMN 
+                caclulateHeight(text, Math.max(measuredWidth, getWidestWordWidth(text))), height);
-                  ? measuredWidth 
-                  : Math.max(measuredWidth, getWidestWordWidth(text))), height);
       } else {
-        measuredHeight = caclulateHeight(text, node.getFlexDirection() == YogaFlexDirection.COLUMN 
+        measuredHeight = caclulateHeight(text, Math.max(measuredWidth, getWidestWordWidth(text)));
-          ? measuredWidth 
-          : Math.max(measuredWidth, getWidestWordWidth(text)));
       }
 
       return YogaMeasureOutput.make(measuredWidth, measuredHeight);

java/tests/generated/com/facebook/yoga/YGAlignItemsTest.java

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<84597dd8b2c4f3aac1f21abe68f25308>>
+ * @generated SignedSource<<e8d11c0e97041bb2f1487f0d87363fdc>>
  * generated by gentest/gentest-driver.ts from gentest/fixtures/YGAlignItemsTest.html
  */
 
@@ -2293,86 +2293,6 @@ public class YGAlignItemsTest {
     assertEquals(50f, root_child1.getLayoutHeight(), 0.0f);
   }
 
-  @Test
-  public void test_align_items_non_stretch_s526008() {
-    YogaConfig config = YogaConfigFactory.create();
-
-    final YogaNode root = createNode(config);
-    root.setPositionType(YogaPositionType.ABSOLUTE);
-    root.setWidth(400f);
-    root.setHeight(400f);
-
-    final YogaNode root_child0 = createNode(config);
-    root_child0.setFlexDirection(YogaFlexDirection.ROW);
-    root.addChildAt(root_child0, 0);
-
-    final YogaNode root_child0_child0 = createNode(config);
-    root_child0_child0.setAlignItems(YogaAlign.FLEX_START);
-    root_child0.addChildAt(root_child0_child0, 0);
-
-    final YogaNode root_child0_child0_child0 = createNode(config);
-    root_child0_child0.addChildAt(root_child0_child0_child0, 0);
-
-    final YogaNode root_child0_child0_child0_child0 = createNode(config);
-    root_child0_child0_child0_child0.setHeight(10f);
-    root_child0_child0_child0.addChildAt(root_child0_child0_child0_child0, 0);
-    root.setDirection(YogaDirection.LTR);
-    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
-
-    assertEquals(0f, root.getLayoutX(), 0.0f);
-    assertEquals(0f, root.getLayoutY(), 0.0f);
-    assertEquals(400f, root.getLayoutWidth(), 0.0f);
-    assertEquals(400f, root.getLayoutHeight(), 0.0f);
-
-    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
-    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
-    assertEquals(400f, root_child0.getLayoutWidth(), 0.0f);
-    assertEquals(10f, root_child0.getLayoutHeight(), 0.0f);
-
-    assertEquals(0f, root_child0_child0.getLayoutX(), 0.0f);
-    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
-    assertEquals(0f, root_child0_child0.getLayoutWidth(), 0.0f);
-    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
-
-    assertEquals(0f, root_child0_child0_child0.getLayoutX(), 0.0f);
-    assertEquals(0f, root_child0_child0_child0.getLayoutY(), 0.0f);
-    assertEquals(0f, root_child0_child0_child0.getLayoutWidth(), 0.0f);
-    assertEquals(10f, root_child0_child0_child0.getLayoutHeight(), 0.0f);
-
-    assertEquals(0f, root_child0_child0_child0_child0.getLayoutX(), 0.0f);
-    assertEquals(0f, root_child0_child0_child0_child0.getLayoutY(), 0.0f);
-    assertEquals(0f, root_child0_child0_child0_child0.getLayoutWidth(), 0.0f);
-    assertEquals(10f, root_child0_child0_child0_child0.getLayoutHeight(), 0.0f);
-
-    root.setDirection(YogaDirection.RTL);
-    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
-
-    assertEquals(0f, root.getLayoutX(), 0.0f);
-    assertEquals(0f, root.getLayoutY(), 0.0f);
-    assertEquals(400f, root.getLayoutWidth(), 0.0f);
-    assertEquals(400f, root.getLayoutHeight(), 0.0f);
-
-    assertEquals(0f, root_child0.getLayoutX(), 0.0f);
-    assertEquals(0f, root_child0.getLayoutY(), 0.0f);
-    assertEquals(400f, root_child0.getLayoutWidth(), 0.0f);
-    assertEquals(10f, root_child0.getLayoutHeight(), 0.0f);
-
-    assertEquals(400f, root_child0_child0.getLayoutX(), 0.0f);
-    assertEquals(0f, root_child0_child0.getLayoutY(), 0.0f);
-    assertEquals(0f, root_child0_child0.getLayoutWidth(), 0.0f);
-    assertEquals(10f, root_child0_child0.getLayoutHeight(), 0.0f);
-
-    assertEquals(0f, root_child0_child0_child0.getLayoutX(), 0.0f);
-    assertEquals(0f, root_child0_child0_child0.getLayoutY(), 0.0f);
-    assertEquals(0f, root_child0_child0_child0.getLayoutWidth(), 0.0f);
-    assertEquals(10f, root_child0_child0_child0.getLayoutHeight(), 0.0f);
-
-    assertEquals(0f, root_child0_child0_child0_child0.getLayoutX(), 0.0f);
-    assertEquals(0f, root_child0_child0_child0_child0.getLayoutY(), 0.0f);
-    assertEquals(0f, root_child0_child0_child0_child0.getLayoutWidth(), 0.0f);
-    assertEquals(10f, root_child0_child0_child0_child0.getLayoutHeight(), 0.0f);
-  }
-
   private YogaNode createNode(YogaConfig config) {
     return mNodeFactory.create(config);
   }

javascript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yoga-layout",
-  "version": "0.0.0",
+  "version": "3.2.1",
   "description": "An embeddable and performant flexbox layout engine with bindings for multiple languages",
   "license": "MIT",
   "author": "Meta Open Source",

javascript/src/Node.cpp

@@ -160,18 +160,6 @@ void Node::setFlexBasisAuto() {
   YGNodeStyleSetFlexBasisAuto(m_node);
 }
 
-void Node::setFlexBasisMaxContent() {
-  YGNodeStyleSetFlexBasisMaxContent(m_node);
-}
-
-void Node::setFlexBasisFitContent() {
-  YGNodeStyleSetFlexBasisFitContent(m_node);
-}
-
-void Node::setFlexBasisStretch() {
-  YGNodeStyleSetFlexBasisStretch(m_node);
-}
-
 void Node::setFlexGrow(double flexGrow) {
   YGNodeStyleSetFlexGrow(m_node, flexGrow);
 }
@@ -192,18 +180,6 @@ void Node::setWidthAuto() {
   YGNodeStyleSetWidthAuto(m_node);
 }
 
-void Node::setWidthMaxContent() {
-  YGNodeStyleSetWidthMaxContent(m_node);
-}
-
-void Node::setWidthFitContent() {
-  YGNodeStyleSetWidthFitContent(m_node);
-}
-
-void Node::setWidthStretch() {
-  YGNodeStyleSetWidthStretch(m_node);
-}
-
 void Node::setHeight(double height) {
   YGNodeStyleSetHeight(m_node, height);
 }
@@ -216,18 +192,6 @@ void Node::setHeightAuto() {
   YGNodeStyleSetHeightAuto(m_node);
 }
 
-void Node::setHeightMaxContent() {
-  YGNodeStyleSetHeightMaxContent(m_node);
-}
-
-void Node::setHeightFitContent() {
-  YGNodeStyleSetHeightFitContent(m_node);
-}
-
-void Node::setHeightStretch() {
-  YGNodeStyleSetHeightStretch(m_node);
-}
-
 void Node::setMinWidth(double minWidth) {
   YGNodeStyleSetMinWidth(m_node, minWidth);
 }
@@ -236,18 +200,6 @@ void Node::setMinWidthPercent(double minWidth) {
   YGNodeStyleSetMinWidthPercent(m_node, minWidth);
 }
 
-void Node::setMinWidthMaxContent() {
-  YGNodeStyleSetMinWidthMaxContent(m_node);
-}
-
-void Node::setMinWidthFitContent() {
-  YGNodeStyleSetMinWidthFitContent(m_node);
-}
-
-void Node::setMinWidthStretch() {
-  YGNodeStyleSetMinWidthStretch(m_node);
-}
-
 void Node::setMinHeight(double minHeight) {
   YGNodeStyleSetMinHeight(m_node, minHeight);
 }
@@ -256,18 +208,6 @@ void Node::setMinHeightPercent(double minHeight) {
   YGNodeStyleSetMinHeightPercent(m_node, minHeight);
 }
 
-void Node::setMinHeightMaxContent() {
-  YGNodeStyleSetMinHeightMaxContent(m_node);
-}
-
-void Node::setMinHeightFitContent() {
-  YGNodeStyleSetMinHeightFitContent(m_node);
-}
-
-void Node::setMinHeightStretch() {
-  YGNodeStyleSetMinHeightStretch(m_node);
-}
-
 void Node::setMaxWidth(double maxWidth) {
   YGNodeStyleSetMaxWidth(m_node, maxWidth);
 }
@@ -276,18 +216,6 @@ void Node::setMaxWidthPercent(double maxWidth) {
   YGNodeStyleSetMaxWidthPercent(m_node, maxWidth);
 }
 
-void Node::setMaxWidthMaxContent() {
-  YGNodeStyleSetMaxWidthMaxContent(m_node);
-}
-
-void Node::setMaxWidthFitContent() {
-  YGNodeStyleSetMaxWidthFitContent(m_node);
-}
-
-void Node::setMaxWidthStretch() {
-  YGNodeStyleSetMaxWidthStretch(m_node);
-}
-
 void Node::setMaxHeight(double maxHeight) {
   YGNodeStyleSetMaxHeight(m_node, maxHeight);
 }
@@ -296,18 +224,6 @@ void Node::setMaxHeightPercent(double maxHeight) {
   YGNodeStyleSetMaxHeightPercent(m_node, maxHeight);
 }
 
-void Node::setMaxHeightMaxContent() {
-  YGNodeStyleSetMaxHeightMaxContent(m_node);
-}
-
-void Node::setMaxHeightFitContent() {
-  YGNodeStyleSetMaxHeightFitContent(m_node);
-}
-
-void Node::setMaxHeightStretch() {
-  YGNodeStyleSetMaxHeightStretch(m_node);
-}
-
 void Node::setAspectRatio(double aspectRatio) {
   YGNodeStyleSetAspectRatio(m_node, aspectRatio);
 }
@@ -439,9 +355,8 @@ Value Node::getPadding(int edge) const {
       YGNodeStyleGetPadding(m_node, static_cast<YGEdge>(edge)));
 }
 
-Value Node::getGap(int gutter) const {
+float Node::getGap(int gutter) {
-  return Value::fromYGValue(
+  return YGNodeStyleGetGap(m_node, static_cast<YGGutter>(gutter));
-      YGNodeStyleGetGap(m_node, static_cast<YGGutter>(gutter)));
 }
 
 bool Node::isReferenceBaseline() {

javascript/src/Node.h

@@ -97,46 +97,25 @@ class Node {
   void setFlexBasis(double flexBasis);
   void setFlexBasisPercent(double flexBasis);
   void setFlexBasisAuto();
-  void setFlexBasisMaxContent();
-  void setFlexBasisFitContent();
-  void setFlexBasisStretch();
   void setFlexGrow(double flexGrow);
   void setFlexShrink(double flexShrink);
 
   void setWidth(double width);
   void setWidthPercent(double width);
   void setWidthAuto();
-  void setWidthMaxContent();
-  void setWidthFitContent();
-  void setWidthStretch();
   void setHeight(double height);
   void setHeightPercent(double height);
   void setHeightAuto();
-  void setHeightMaxContent();
-  void setHeightFitContent();
-  void setHeightStretch();
 
   void setMinWidth(double minWidth);
   void setMinWidthPercent(double minWidth);
-  void setMinWidthMaxContent();
-  void setMinWidthFitContent();
-  void setMinWidthStretch();
   void setMinHeight(double minHeight);
   void setMinHeightPercent(double minHeight);
-  void setMinHeightMaxContent();
-  void setMinHeightFitContent();
-  void setMinHeightStretch();
 
   void setMaxWidth(double maxWidth);
   void setMaxWidthPercent(double maxWidth);
-  void setMaxWidthMaxContent();
-  void setMaxWidthFitContent();
-  void setMaxWidthStretch();
   void setMaxHeight(double maxHeight);
   void setMaxHeightPercent(double maxHeight);
-  void setMaxHeightMaxContent();
-  void setMaxHeightFitContent();
-  void setMaxHeightStretch();
 
   void setAspectRatio(double aspectRatio);
 
@@ -186,7 +165,7 @@ class Node {
 
   Value getPadding(int edge) const;
 
-  Value getGap(int gutter) const;
+  float getGap(int gutter);
 
   int getBoxSizing(void) const;
 

javascript/src/embind.cpp

@@ -90,46 +90,25 @@ EMSCRIPTEN_BINDINGS(YOGA_LAYOUT) {
       .function("setFlexBasis", &Node::setFlexBasis)
       .function("setFlexBasisPercent", &Node::setFlexBasisPercent)
       .function("setFlexBasisAuto", &Node::setFlexBasisAuto)
-      .function("setFlexBasisMaxContent", &Node::setFlexBasisMaxContent)
-      .function("setFlexBasisFitContent", &Node::setFlexBasisFitContent)
-      .function("setFlexBasisStretch", &Node::setFlexBasisStretch)
       .function("setFlexGrow", &Node::setFlexGrow)
       .function("setFlexShrink", &Node::setFlexShrink)
 
       .function("setWidth", &Node::setWidth)
       .function("setWidthPercent", &Node::setWidthPercent)
       .function("setWidthAuto", &Node::setWidthAuto)
-      .function("setWidthMaxContent", &Node::setWidthMaxContent)
-      .function("setWidthFitContent", &Node::setWidthFitContent)
-      .function("setWidthStretch", &Node::setWidthStretch)
       .function("setHeight", &Node::setHeight)
       .function("setHeightPercent", &Node::setHeightPercent)
       .function("setHeightAuto", &Node::setHeightAuto)
-      .function("setHeightMaxContent", &Node::setHeightMaxContent)
-      .function("setHeightFitContent", &Node::setHeightFitContent)
-      .function("setHeightStretch", &Node::setHeightStretch)
 
       .function("setMinWidth", &Node::setMinWidth)
       .function("setMinWidthPercent", &Node::setMinWidthPercent)
-      .function("setMinWidthMaxContent", &Node::setMinWidthMaxContent)
-      .function("setMinWidthFitContent", &Node::setMinWidthFitContent)
-      .function("setMinWidthStretch", &Node::setMinWidthStretch)
       .function("setMinHeight", &Node::setMinHeight)
       .function("setMinHeightPercent", &Node::setMinHeightPercent)
-      .function("setMinHeightMaxContent", &Node::setMinHeightMaxContent)
-      .function("setMinHeightFitContent", &Node::setMinHeightFitContent)
-      .function("setMinHeightStretch", &Node::setMinHeightStretch)
 
       .function("setMaxWidth", &Node::setMaxWidth)
       .function("setMaxWidthPercent", &Node::setMaxWidthPercent)
-      .function("setMaxWidthMaxContent", &Node::setMaxWidthMaxContent)
-      .function("setMaxWidthFitContent", &Node::setMaxWidthFitContent)
-      .function("setMaxWidthStretch", &Node::setMaxWidthStretch)
       .function("setMaxHeight", &Node::setMaxHeight)
       .function("setMaxHeightPercent", &Node::setMaxHeightPercent)
-      .function("setMaxHeightMaxContent", &Node::setMaxHeightMaxContent)
-      .function("setMaxHeightFitContent", &Node::setMaxHeightFitContent)
-      .function("setMaxHeightStretch", &Node::setMaxHeightStretch)
 
       .function("setBoxSizing", &Node::setBoxSizing)
 

javascript/src/generated/YGEnums.ts

@@ -125,9 +125,6 @@ export enum Unit {
   Point = 1,
   Percent = 2,
   Auto = 3,
-  MaxContent = 4,
-  FitContent = 5,
-  Stretch = 6,
 }
 
 export enum Wrap {
@@ -206,9 +203,6 @@ const constants = {
   UNIT_POINT: Unit.Point,
   UNIT_PERCENT: Unit.Percent,
   UNIT_AUTO: Unit.Auto,
-  UNIT_MAX_CONTENT: Unit.MaxContent,
-  UNIT_FIT_CONTENT: Unit.FitContent,
-  UNIT_STRETCH: Unit.Stretch,
   WRAP_NO_WRAP: Wrap.NoWrap,
   WRAP_WRAP: Wrap.Wrap,
   WRAP_WRAP_REVERSE: Wrap.WrapReverse,

javascript/src/wrapAssembly.ts

@@ -134,41 +134,17 @@ export type Node = {
   setDirection(direction: Direction): void;
   setDisplay(display: Display): void;
   setFlex(flex: number | undefined): void;
-  setFlexBasis(
+  setFlexBasis(flexBasis: number | 'auto' | `${number}%` | undefined): void;
-    flexBasis:
-      | number
-      | 'auto'
-      | 'fit-content'
-      | 'max-content'
-      | 'stretch'
-      | `${number}%`
-      | undefined,
-  ): void;
   setFlexBasisPercent(flexBasis: number | undefined): void;
   setFlexBasisAuto(): void;
-  setFlexBasisFitContent(): void;
-  setFlexBasisMaxContent(): void;
-  setFlexBasisStretch(): void;
   setFlexDirection(flexDirection: FlexDirection): void;
   setFlexGrow(flexGrow: number | undefined): void;
   setFlexShrink(flexShrink: number | undefined): void;
   setFlexWrap(flexWrap: Wrap): void;
-  setHeight(
+  setHeight(height: number | 'auto' | `${number}%` | undefined): void;
-    height:
-      | number
-      | 'auto'
-      | 'fit-content'
-      | 'max-content'
-      | 'stretch'
-      | `${number}%`
-      | undefined,
-  ): void;
   setIsReferenceBaseline(isReferenceBaseline: boolean): void;
   setHeightAuto(): void;
-  setHeightFitContent(): void;
-  setHeightMaxContent(): void;
   setHeightPercent(height: number | undefined): void;
-  setHeightStretch(): void;
   setJustifyContent(justifyContent: Justify): void;
   setGap(gutter: Gutter, gapLength: number | `${number}%` | undefined): Value;
   setGapPercent(gutter: Gutter, gapLength: number | undefined): Value;
@@ -178,60 +154,16 @@ export type Node = {
   ): void;
   setMarginAuto(edge: Edge): void;
   setMarginPercent(edge: Edge, margin: number | undefined): void;
-  setMaxHeight(
+  setMaxHeight(maxHeight: number | `${number}%` | undefined): void;
-    maxHeight:
-      | number
-      | 'fit-content'
-      | 'max-content'
-      | 'stretch'
-      | `${number}%`
-      | undefined,
-  ): void;
-  setMaxHeightFitContent(): void;
-  setMaxHeightMaxContent(): void;
   setMaxHeightPercent(maxHeight: number | undefined): void;
-  setMaxHeightStretch(): void;
+  setMaxWidth(maxWidth: number | `${number}%` | undefined): void;
-  setMaxWidth(
-    maxWidth:
-      | number
-      | 'fit-content'
-      | 'max-content'
-      | 'stretch'
-      | `${number}%`
-      | undefined,
-  ): void;
-  setMaxWidthFitContent(): void;
-  setMaxWidthMaxContent(): void;
   setMaxWidthPercent(maxWidth: number | undefined): void;
-  setMaxWidthStretch(): void;
   setDirtiedFunc(dirtiedFunc: DirtiedFunction | null): void;
   setMeasureFunc(measureFunc: MeasureFunction | null): void;
-  setMinHeight(
+  setMinHeight(minHeight: number | `${number}%` | undefined): void;
-    minHeight:
-      | number
-      | 'fit-content'
-      | 'max-content'
-      | 'stretch'
-      | `${number}%`
-      | undefined,
-  ): void;
-  setMinHeightFitContent(): void;
-  setMinHeightMaxContent(): void;
   setMinHeightPercent(minHeight: number | undefined): void;
-  setMinHeightStretch(): void;
+  setMinWidth(minWidth: number | `${number}%` | undefined): void;
-  setMinWidth(
-    minWidth:
-      | number
-      | 'fit-content'
-      | 'max-content'
-      | 'stretch'
-      | `${number}%`
-      | undefined,
-  ): void;
-  setMinWidthFitContent(): void;
-  setMinWidthMaxContent(): void;
   setMinWidthPercent(minWidth: number | undefined): void;
-  setMinWidthStretch(): void;
   setOverflow(overflow: Overflow): void;
   setPadding(edge: Edge, padding: number | `${number}%` | undefined): void;
   setPaddingPercent(edge: Edge, padding: number | undefined): void;
@@ -240,21 +172,9 @@ export type Node = {
   setPositionType(positionType: PositionType): void;
   setPositionAuto(edge: Edge): void;
   setBoxSizing(boxSizing: BoxSizing): void;
-  setWidth(
+  setWidth(width: number | 'auto' | `${number}%` | undefined): void;
-    width:
-      | number
-      | 'auto'
-      | 'fit-content'
-      | 'max-content'
-      | 'stretch'
-      | `${number}%`
-      | undefined,
-  ): void;
   setWidthAuto(): void;
-  setWidthFitContent(): void;
-  setWidthMaxContent(): void;
   setWidthPercent(width: number | undefined): void;
-  setWidthStretch(): void;
   unsetDirtiedFunc(): void;
   unsetMeasureFunc(): void;
   setAlwaysFormsContainingBlock(alwaysFormsContainingBlock: boolean): void;
@@ -300,9 +220,6 @@ export default function wrapAssembly(lib: any): Yoga {
       [Unit.Point]: lib.Node.prototype[fnName],
       [Unit.Percent]: lib.Node.prototype[`${fnName}Percent`],
       [Unit.Auto]: lib.Node.prototype[`${fnName}Auto`],
-      [Unit.MaxContent]: lib.Node.prototype[`${fnName}MaxContent`],
-      [Unit.FitContent]: lib.Node.prototype[`${fnName}FitContent`],
-      [Unit.Stretch]: lib.Node.prototype[`${fnName}Stretch`],
     };
 
     patch(lib.Node.prototype, fnName, function (original, ...args) {
@@ -315,15 +232,6 @@ export default function wrapAssembly(lib: any): Yoga {
       if (value === 'auto') {
         unit = Unit.Auto;
         asNumber = undefined;
-      } else if (value == 'max-content') {
-        unit = Unit.MaxContent;
-        asNumber = undefined;
-      } else if (value == 'fit-content') {
-        unit = Unit.FitContent;
-        asNumber = undefined;
-      } else if (value == 'stretch') {
-        unit = Unit.Stretch;
-        asNumber = undefined;
       } else if (typeof value === 'object') {
         unit = value.unit;
         asNumber = value.valueOf();

javascript/tests/generated/YGAlignItemsTest.test.ts

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<fd80af208d8635435f86ffa8f3810b39>>
+ * @generated SignedSource<<075a0b67003e5c4a1f51bd99da71c700>>
  * generated by gentest/gentest-driver.ts from gentest/fixtures/YGAlignItemsTest.html
  */
 
@@ -2442,88 +2442,3 @@ test('align_stretch_with_row_reverse', () => {
     config.free();
   }
 });
-test('align_items_non_stretch_s526008', () => {
-  const config = Yoga.Config.create();
-  let root;
-
-  try {
-    root = Yoga.Node.create(config);
-    root.setPositionType(PositionType.Absolute);
-    root.setWidth(400);
-    root.setHeight(400);
-
-    const root_child0 = Yoga.Node.create(config);
-    root_child0.setFlexDirection(FlexDirection.Row);
-    root.insertChild(root_child0, 0);
-
-    const root_child0_child0 = Yoga.Node.create(config);
-    root_child0_child0.setAlignItems(Align.FlexStart);
-    root_child0.insertChild(root_child0_child0, 0);
-
-    const root_child0_child0_child0 = Yoga.Node.create(config);
-    root_child0_child0.insertChild(root_child0_child0_child0, 0);
-
-    const root_child0_child0_child0_child0 = Yoga.Node.create(config);
-    root_child0_child0_child0_child0.setHeight(10);
-    root_child0_child0_child0.insertChild(root_child0_child0_child0_child0, 0);
-    root.calculateLayout(undefined, undefined, Direction.LTR);
-
-    expect(root.getComputedLeft()).toBe(0);
-    expect(root.getComputedTop()).toBe(0);
-    expect(root.getComputedWidth()).toBe(400);
-    expect(root.getComputedHeight()).toBe(400);
-
-    expect(root_child0.getComputedLeft()).toBe(0);
-    expect(root_child0.getComputedTop()).toBe(0);
-    expect(root_child0.getComputedWidth()).toBe(400);
-    expect(root_child0.getComputedHeight()).toBe(10);
-
-    expect(root_child0_child0.getComputedLeft()).toBe(0);
-    expect(root_child0_child0.getComputedTop()).toBe(0);
-    expect(root_child0_child0.getComputedWidth()).toBe(0);
-    expect(root_child0_child0.getComputedHeight()).toBe(10);
-
-    expect(root_child0_child0_child0.getComputedLeft()).toBe(0);
-    expect(root_child0_child0_child0.getComputedTop()).toBe(0);
-    expect(root_child0_child0_child0.getComputedWidth()).toBe(0);
-    expect(root_child0_child0_child0.getComputedHeight()).toBe(10);
-
-    expect(root_child0_child0_child0_child0.getComputedLeft()).toBe(0);
-    expect(root_child0_child0_child0_child0.getComputedTop()).toBe(0);
-    expect(root_child0_child0_child0_child0.getComputedWidth()).toBe(0);
-    expect(root_child0_child0_child0_child0.getComputedHeight()).toBe(10);
-
-    root.calculateLayout(undefined, undefined, Direction.RTL);
-
-    expect(root.getComputedLeft()).toBe(0);
-    expect(root.getComputedTop()).toBe(0);
-    expect(root.getComputedWidth()).toBe(400);
-    expect(root.getComputedHeight()).toBe(400);
-
-    expect(root_child0.getComputedLeft()).toBe(0);
-    expect(root_child0.getComputedTop()).toBe(0);
-    expect(root_child0.getComputedWidth()).toBe(400);
-    expect(root_child0.getComputedHeight()).toBe(10);
-
-    expect(root_child0_child0.getComputedLeft()).toBe(400);
-    expect(root_child0_child0.getComputedTop()).toBe(0);
-    expect(root_child0_child0.getComputedWidth()).toBe(0);
-    expect(root_child0_child0.getComputedHeight()).toBe(10);
-
-    expect(root_child0_child0_child0.getComputedLeft()).toBe(0);
-    expect(root_child0_child0_child0.getComputedTop()).toBe(0);
-    expect(root_child0_child0_child0.getComputedWidth()).toBe(0);
-    expect(root_child0_child0_child0.getComputedHeight()).toBe(10);
-
-    expect(root_child0_child0_child0_child0.getComputedLeft()).toBe(0);
-    expect(root_child0_child0_child0_child0.getComputedTop()).toBe(0);
-    expect(root_child0_child0_child0_child0.getComputedWidth()).toBe(0);
-    expect(root_child0_child0_child0_child0.getComputedHeight()).toBe(10);
-  } finally {
-    if (typeof root !== 'undefined') {
-      root.freeRecursive();
-    }
-
-    config.free();
-  }
-});

javascript/tests/tools/utils.ts

@@ -5,23 +5,17 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import {FlexDirection, MeasureMode} from 'yoga-layout';
+import {MeasureMode} from 'yoga-layout';
-
-type MeasureContext = {
-  text: string;
-  flexDirection: FlexDirection;
-};
 
 export function instrinsicSizeMeasureFunc(
-  this: MeasureContext,
+  this: string,
   width: number,
   widthMode: MeasureMode,
   height: number,
   heightMode: MeasureMode,
 ): {width: number; height: number} {
-  const textLength = this.text.length;
+  const textLength = this.length;
-  const words = this.text.split(' ');
+  const words = this.split(' ');
-  const flexDirection = this.flexDirection;
   const widthPerChar = 10;
   const heightPerChar = 10;
 
@@ -59,10 +53,7 @@ export function instrinsicSizeMeasureFunc(
       return heightPerChar;
     }
 
-    const maxLineWidth =
+    const maxLineWidth = Math.max(longestWordWidth(), measuredWidth);
-      flexDirection == FlexDirection.Column
-        ? measuredWidth
-        : Math.max(longestWordWidth(), measuredWidth);
 
     //if fixed width < width of widest word, take width of widest word
 

settings.gradle.kts

@@ -19,11 +19,10 @@ include(":yoga")
 
 project(":yoga").projectDir = file("java")
 
-gradleEnterprise {
-  buildScan {
-    termsOfServiceUrl = "https://gradle.com/terms-of-service"
-    termsOfServiceAgree = "yes"
-  }
-}
-
 rootProject.name = "yoga-github"
+
+// If you specify a file inside gradle/gradle-enterprise.gradle.kts
+// you can configure your custom Gradle Enterprise instance
+if (file("./gradle/gradle-enterprise.gradle.kts").exists()) {
+  apply(from = "./gradle/gradle-enterprise.gradle.kts")
+}

tests/.clang-tidy

@@ -1,7 +0,0 @@
----
-InheritParentConfig: true
-Checks: '
--facebook-hte-CArray,
--modernize-avoid-c-arrays,
-'
-...

tests/StyleValuePoolTest.cpp

@@ -128,19 +128,4 @@ TEST(StyleValuePool, store_undefined_after_large_int) {
   EXPECT_EQ(pool.getLength(handle), StyleLength::undefined());
 }
 
-TEST(StyleValuePool, store_keywords) {
-  StyleValuePool pool;
-  StyleValueHandle handleMaxContent;
-  StyleValueHandle handleFitContent;
-  StyleValueHandle handleStretch;
-
-  pool.store(handleMaxContent, StyleSizeLength::ofMaxContent());
-  pool.store(handleFitContent, StyleSizeLength::ofFitContent());
-  pool.store(handleStretch, StyleSizeLength::ofStretch());
-
-  EXPECT_EQ(pool.getSize(handleMaxContent), StyleSizeLength::ofMaxContent());
-  EXPECT_EQ(pool.getSize(handleFitContent), StyleSizeLength::ofFitContent());
-  EXPECT_EQ(pool.getSize(handleStretch), StyleSizeLength::ofStretch());
-}
-
 } // namespace facebook::yoga

tests/YGPersistentNodeCloningTest.cpp

@@ -1,214 +0,0 @@
-/*
- * 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 <gtest/gtest.h>
-#include <yoga/Yoga.h>
-#include <yoga/config/Config.h>
-#include <yoga/node/Node.h>
-
-#include <functional>
-#include <memory>
-#include <vector>
-
-namespace facebook::yoga {
-
-struct YGPersistentNodeCloningTest : public ::testing::Test {
-  struct NodeWrapper {
-    explicit NodeWrapper(
-        YGConfigRef config,
-        std::vector<std::shared_ptr<NodeWrapper>> children = {})
-        : node{YGNodeNewWithConfig(config)}, children{std::move(children)} {
-      YGNodeSetContext(node, this);
-
-      auto privateNode = resolveRef(node);
-      for (const auto& child : this->children) {
-        auto privateChild = resolveRef(child->node);
-        // Claim first ownership of not yet owned nodes, to avoid immediately
-        // cloning them
-        if (YGNodeGetOwner(child->node) == nullptr) {
-          privateChild->setOwner(privateNode);
-        }
-        privateNode->insertChild(privateChild, privateNode->getChildCount());
-      }
-    }
-
-    // Clone, with current children, for mutation
-    NodeWrapper(const NodeWrapper& other)
-        : node{YGNodeClone(other.node)}, children{other.children} {
-      YGNodeSetContext(node, this);
-
-      auto privateNode = resolveRef(node);
-      privateNode->setOwner(nullptr);
-    }
-
-    // Clone, with new children
-    NodeWrapper(
-        const NodeWrapper& other,
-        std::vector<std::shared_ptr<NodeWrapper>> children)
-        : node{YGNodeClone(other.node)}, children{std::move(children)} {
-      YGNodeSetContext(node, this);
-
-      auto privateNode = resolveRef(node);
-      privateNode->setOwner(nullptr);
-      privateNode->setChildren({});
-      privateNode->setDirty(true);
-
-      for (const auto& child : this->children) {
-        auto privateChild = resolveRef(child->node);
-        // Claim first ownership of not yet owned nodes, to avoid immediately
-        // cloning them
-        if (YGNodeGetOwner(child->node) == nullptr) {
-          privateChild->setOwner(privateNode);
-        }
-        privateNode->insertChild(privateChild, privateNode->getChildCount());
-      }
-    }
-
-    NodeWrapper(NodeWrapper&&) = delete;
-
-    ~NodeWrapper() {
-      YGNodeFree(node);
-    }
-
-    NodeWrapper& operator=(const NodeWrapper& other) = delete;
-    NodeWrapper& operator=(NodeWrapper&& other) = delete;
-
-    YGNodeRef node;
-    std::vector<std::shared_ptr<NodeWrapper>> children;
-  };
-
-  struct ConfigWrapper {
-    ConfigWrapper() {
-      YGConfigSetCloneNodeFunc(
-          config,
-          [](YGNodeConstRef oldNode, YGNodeConstRef owner, size_t childIndex) {
-            onClone(oldNode, owner, childIndex);
-            auto wrapper = static_cast<NodeWrapper*>(YGNodeGetContext(owner));
-            auto old = static_cast<NodeWrapper*>(YGNodeGetContext(oldNode));
-
-            wrapper->children[childIndex] = std::make_shared<NodeWrapper>(*old);
-            return wrapper->children[childIndex]->node;
-          });
-    }
-
-    ConfigWrapper(const ConfigWrapper&) = delete;
-    ConfigWrapper(ConfigWrapper&&) = delete;
-
-    ~ConfigWrapper() {
-      YGConfigFree(config);
-    }
-
-    ConfigWrapper& operator=(const ConfigWrapper&) = delete;
-    ConfigWrapper& operator=(ConfigWrapper&&) = delete;
-
-    YGConfigRef config{YGConfigNew()};
-  };
-
-  ConfigWrapper configWrapper;
-  YGConfigRef config{configWrapper.config};
-
-  void SetUp() override {
-    onClone = [](...) {};
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  static inline std::function<void(YGNodeConstRef, YGNodeConstRef, size_t)>
-      onClone;
-};
-
-TEST_F(
-    YGPersistentNodeCloningTest,
-    changing_sibling_height_does_not_clone_neighbors) {
-  // <ScrollView>
-  //   <View id="Sibling" style={{ height: 1 }} />
-  //   <View id="A" style={{ height: 1 }}>
-  //     <View id="B">
-  //       <View id="C">
-  //         <View id="D"/>
-  //       </View>
-  //     </View>
-  //   </View>
-  // </ScrollView>
-
-  auto sibling = std::make_shared<NodeWrapper>(config);
-  YGNodeStyleSetHeight(sibling->node, 1);
-
-  auto d = std::make_shared<NodeWrapper>(config);
-  auto c = std::make_shared<NodeWrapper>(config, std::vector{d});
-  auto b = std::make_shared<NodeWrapper>(config, std::vector{c});
-  auto a = std::make_shared<NodeWrapper>(config, std::vector{b});
-  YGNodeStyleSetHeight(a->node, 1);
-
-  auto scrollContentView =
-      std::make_shared<NodeWrapper>(config, std::vector{sibling, a});
-  YGNodeStyleSetPositionType(scrollContentView->node, YGPositionTypeAbsolute);
-
-  auto scrollView =
-      std::make_shared<NodeWrapper>(config, std::vector{scrollContentView});
-  YGNodeStyleSetWidth(scrollView->node, 100);
-  YGNodeStyleSetHeight(scrollView->node, 100);
-
-  // We don't expect any cloning during the first layout
-  onClone = [](...) { FAIL(); };
-
-  YGNodeCalculateLayout(
-      scrollView->node, YGUndefined, YGUndefined, YGDirectionLTR);
-
-  auto siblingPrime = std::make_shared<NodeWrapper>(config);
-  YGNodeStyleSetHeight(siblingPrime->node, 2);
-
-  auto scrollContentViewPrime = std::make_shared<NodeWrapper>(
-      *scrollContentView, std::vector{siblingPrime, a});
-  auto scrollViewPrime = std::make_shared<NodeWrapper>(
-      *scrollView, std::vector{scrollContentViewPrime});
-
-  std::vector<NodeWrapper*> nodesCloned;
-  // We should only need to clone "A"
-  onClone = [&](YGNodeConstRef oldNode,
-                YGNodeConstRef /*owner*/,
-                size_t /*childIndex*/) {
-    nodesCloned.push_back(static_cast<NodeWrapper*>(YGNodeGetContext(oldNode)));
-  };
-
-  YGNodeCalculateLayout(
-      scrollViewPrime->node, YGUndefined, YGUndefined, YGDirectionLTR);
-
-  EXPECT_EQ(nodesCloned.size(), 1);
-  EXPECT_EQ(nodesCloned[0], a.get());
-}
-
-TEST_F(YGPersistentNodeCloningTest, clone_leaf_display_contents_node) {
-  // <View id="A">
-  //   <View id="B" style={{ display: 'contents' }} />
-  // </View>
-
-  auto b = std::make_shared<NodeWrapper>(config);
-  auto a = std::make_shared<NodeWrapper>(config, std::vector{b});
-  YGNodeStyleSetDisplay(b->node, YGDisplayContents);
-
-  // We don't expect any cloning during the first layout
-  onClone = [](...) { FAIL(); };
-
-  YGNodeCalculateLayout(a->node, YGUndefined, YGUndefined, YGDirectionLTR);
-
-  auto aPrime = std::make_shared<NodeWrapper>(config, std::vector{b});
-
-  std::vector<NodeWrapper*> nodesCloned;
-  // We should clone "C"
-  onClone = [&](YGNodeConstRef oldNode,
-                YGNodeConstRef /*owner*/,
-                size_t /*childIndex*/) {
-    nodesCloned.push_back(static_cast<NodeWrapper*>(YGNodeGetContext(oldNode)));
-  };
-
-  YGNodeCalculateLayout(aPrime->node, 100, 100, YGDirectionLTR);
-
-  EXPECT_EQ(nodesCloned.size(), 1);
-  EXPECT_EQ(nodesCloned[0], b.get());
-}
-
-} // namespace facebook::yoga

tests/YGRoundingFunctionTest.cpp

@@ -8,8 +8,6 @@
 #include <gtest/gtest.h>
 #include <yoga/Yoga.h>
 
-#include <cmath>
-
 TEST(YogaTest, rounding_value) {
   // Test that whole numbers are rounded to whole despite ceil/floor flags
   ASSERT_FLOAT_EQ(6.0, YGRoundValueToPixelGrid(6.000001, 2.0, false, false));
@@ -41,44 +39,6 @@ TEST(YogaTest, rounding_value) {
   ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-5.99, 2.0, false, false));
   ASSERT_FLOAT_EQ(-5.5, YGRoundValueToPixelGrid(-5.99, 2.0, true, false));
   ASSERT_FLOAT_EQ(-6.0, YGRoundValueToPixelGrid(-5.99, 2.0, false, true));
-
-  // Rounding up/down halfway values is as expected for both positive and
-  // negative numbers
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3.5, 1.0, false, false));
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3.4, 1.0, false, false));
-  ASSERT_FLOAT_EQ(-4, YGRoundValueToPixelGrid(-3.6, 1.0, false, false));
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3.499999, 1.0, false, false));
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3.500001, 1.0, false, false));
-  ASSERT_FLOAT_EQ(-4, YGRoundValueToPixelGrid(-3.5001, 1.0, false, false));
-
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3.5, 1.0, true, false));
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3.4, 1.0, true, false));
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3.6, 1.0, true, false));
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3.499999, 1.0, true, false));
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3.500001, 1.0, true, false));
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3.5001, 1.0, true, false));
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3.00001, 1.0, true, false));
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3, 1.0, true, false));
-
-  ASSERT_FLOAT_EQ(-4, YGRoundValueToPixelGrid(-3.5, 1.0, false, true));
-  ASSERT_FLOAT_EQ(-4, YGRoundValueToPixelGrid(-3.4, 1.0, false, true));
-  ASSERT_FLOAT_EQ(-4, YGRoundValueToPixelGrid(-3.6, 1.0, false, true));
-  ASSERT_FLOAT_EQ(-4, YGRoundValueToPixelGrid(-3.499999, 1.0, false, true));
-  ASSERT_FLOAT_EQ(-4, YGRoundValueToPixelGrid(-3.500001, 1.0, false, true));
-  ASSERT_FLOAT_EQ(-4, YGRoundValueToPixelGrid(-3.5001, 1.0, false, true));
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3.00001, 1.0, false, true));
-  ASSERT_FLOAT_EQ(-3, YGRoundValueToPixelGrid(-3, 1.0, false, true));
-
-  // NAN is treated as expected:
-  ASSERT_TRUE(std::isnan(YGRoundValueToPixelGrid(
-      std::numeric_limits<double>::quiet_NaN(), 1.5, false, false)));
-  ASSERT_TRUE(std::isnan(YGRoundValueToPixelGrid(
-      1.5, std::numeric_limits<double>::quiet_NaN(), false, false)));
-  ASSERT_TRUE(std::isnan(YGRoundValueToPixelGrid(
-      std::numeric_limits<double>::quiet_NaN(),
-      std::numeric_limits<double>::quiet_NaN(),
-      false,
-      false)));
 }
 
 static YGSize measureText(
@@ -161,23 +121,3 @@ TEST(YogaTest, per_node_point_scale_factor) {
   YGConfigFree(config2);
   YGConfigFree(config3);
 }
-
-TEST(YogaTest, raw_layout_dimensions) {
-  YGConfigRef config = YGConfigNew();
-  YGConfigSetPointScaleFactor(config, 0.5f);
-
-  YGNodeRef root = YGNodeNewWithConfig(config);
-  YGNodeStyleSetWidth(root, 11.5f);
-  YGNodeStyleSetHeight(root, 9.5f);
-
-  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
-
-  ASSERT_EQ(YGNodeLayoutGetWidth(root), 12.0f);
-  ASSERT_EQ(YGNodeLayoutGetHeight(root), 10.0f);
-  ASSERT_EQ(YGNodeLayoutGetRawWidth(root), 11.5f);
-  ASSERT_EQ(YGNodeLayoutGetRawHeight(root), 9.5f);
-
-  YGNodeFreeRecursive(root);
-
-  YGConfigFree(config);
-}

tests/generated/YGAlignItemsTest.cpp

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  *
  * clang-format off
- * @generated SignedSource<<1db57b05babb408c08efcec7dbdf16fb>>
+ * @generated SignedSource<<71295a398c89ea424490884a05e2c77c>>
  * generated by gentest/gentest-driver.ts from gentest/fixtures/YGAlignItemsTest.html
  */
 
@@ -2310,84 +2310,3 @@ TEST(YogaTest, align_stretch_with_row_reverse) {
 
   YGConfigFree(config);
 }
-
-TEST(YogaTest, align_items_non_stretch_s526008) {
-  YGConfigRef config = YGConfigNew();
-
-  YGNodeRef root = YGNodeNewWithConfig(config);
-  YGNodeStyleSetPositionType(root, YGPositionTypeAbsolute);
-  YGNodeStyleSetWidth(root, 400);
-  YGNodeStyleSetHeight(root, 400);
-
-  YGNodeRef root_child0 = YGNodeNewWithConfig(config);
-  YGNodeStyleSetFlexDirection(root_child0, YGFlexDirectionRow);
-  YGNodeInsertChild(root, root_child0, 0);
-
-  YGNodeRef root_child0_child0 = YGNodeNewWithConfig(config);
-  YGNodeStyleSetAlignItems(root_child0_child0, YGAlignFlexStart);
-  YGNodeInsertChild(root_child0, root_child0_child0, 0);
-
-  YGNodeRef root_child0_child0_child0 = YGNodeNewWithConfig(config);
-  YGNodeInsertChild(root_child0_child0, root_child0_child0_child0, 0);
-
-  YGNodeRef root_child0_child0_child0_child0 = YGNodeNewWithConfig(config);
-  YGNodeStyleSetHeight(root_child0_child0_child0_child0, 10);
-  YGNodeInsertChild(root_child0_child0_child0, root_child0_child0_child0_child0, 0);
-  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
-
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
-  ASSERT_FLOAT_EQ(400, YGNodeLayoutGetWidth(root));
-  ASSERT_FLOAT_EQ(400, YGNodeLayoutGetHeight(root));
-
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
-  ASSERT_FLOAT_EQ(400, YGNodeLayoutGetWidth(root_child0));
-  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0));
-
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0_child0));
-  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
-
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0_child0_child0));
-  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0_child0));
-
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0_child0_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0_child0_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0_child0_child0_child0));
-  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0_child0_child0));
-
-  YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionRTL);
-
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root));
-  ASSERT_FLOAT_EQ(400, YGNodeLayoutGetWidth(root));
-  ASSERT_FLOAT_EQ(400, YGNodeLayoutGetHeight(root));
-
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0));
-  ASSERT_FLOAT_EQ(400, YGNodeLayoutGetWidth(root_child0));
-  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0));
-
-  ASSERT_FLOAT_EQ(400, YGNodeLayoutGetLeft(root_child0_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0_child0));
-  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0));
-
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0_child0_child0));
-  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0_child0));
-
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetLeft(root_child0_child0_child0_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetTop(root_child0_child0_child0_child0));
-  ASSERT_FLOAT_EQ(0, YGNodeLayoutGetWidth(root_child0_child0_child0_child0));
-  ASSERT_FLOAT_EQ(10, YGNodeLayoutGetHeight(root_child0_child0_child0_child0));
-
-  YGNodeFreeRecursive(root);
-
-  YGConfigFree(config);
-}

tests/util/TestUtil.cpp

@@ -90,20 +90,14 @@ YGSize IntrinsicSizeMeasure(
     measuredHeight = std::min(
         calculateHeight(
             innerText,
-            YGNodeStyleGetFlexDirection(node) == YGFlexDirectionColumn
+            std::max(longestWordWidth(innerText, widthPerChar), measuredWidth),
-                ? measuredWidth
-                : std::max(
-                      longestWordWidth(innerText, widthPerChar), measuredWidth),
             widthPerChar,
             heightPerChar),
         height);
   } else {
     measuredHeight = calculateHeight(
         innerText,
-        YGNodeStyleGetFlexDirection(node) == YGFlexDirectionColumn
+        std::max(longestWordWidth(innerText, widthPerChar), measuredWidth),
-            ? measuredWidth
-            : std::max(
-                  longestWordWidth(innerText, widthPerChar), measuredWidth),
         widthPerChar,
         heightPerChar);
   }

website/blog/2024-12-02-announcing-yoga-3.2.md

@@ -1,83 +0,0 @@
----
-slug: announcing-yoga-3.2
-title: Announcing Yoga 3.2
-authors:
-  - NickGerleman
----
-
-import Playground from '@site/src/components/Playground';
-
-Yoga 3.2 is a new minor version of Yoga, used by React Native 0.77.
-
-## Highlights
-
-1. Support for `box-sizing`
-2. Support for `display: contents`
-3. Bug fixes and improvements
-
-## `box-sizing`
-
-Yoga [now supports](https://github.com/facebook/yoga/commit/671ae61a39d02091d1e73fe773d6a09f2f93cda4) [`box-sizing`](https://developer.mozilla.org/en-US/docs/Web/CSS/box-sizing) on styles, allowing sizing values to influence the content box instead of the border box.
-
-:::warning
-
-To preserve compatibility, Yoga nodes default to `box-sizing: border-box`, even if `UseWebDefaults` is set. We recommend manually setting node defaults instead of using the `UseWebDefaults` API.
-
-:::
-
-<Playground code={`<Layout config={{useWebDefaults: true}}>
-  <Node
-    style={{
-      width: 100,
-      height: 100,
-      padding: 50,
-      boxSizing: "border-box",
-    }}>
-  </Node>
-</Layout>`} />
-
-<Playground code={`<Layout config={{useWebDefaults: true}}>
-    <Node
-    style={{
-      width: 100,
-      height: 100,
-      padding: 50,
-      boxSizing: "content-box",
-    }}>
-  </Node>
-</Layout>`} />
-
-
-
-## `display: contents`
-
-Yoga nodes [may now be set to `display: contents`](https://github.com/facebook/yoga/commit/68bb2343d2b470962065789d09016bba8e785340) to remove them from the layout flow, while preserving and hoisting the node's children. This may be used by the higher level UI framework to allow more easily composing wrapper components (such as those which may need to handle events, without influencing child layout). Thanks [@j-piasecki](https://github.com/j-piasecki) for the contribution!
-
-<Playground code={`<Layout config={{useWebDefaults: false}}>
-  <Node
-    style={{
-      width: 100,
-      height: 100,
-      gap: 10,
-    }}
-  >
-    <Node style={{display: "contents"}}>
-      <Node style={{flexGrow: 1}} />
-      <Node style={{flexGrow: 1}} />
-      <Node style={{flexGrow: 1}} />
-    </Node>
-  </Node>
-</Layout>`} />
-
-
-## Removal of legacy absolute positioning
-
-Yoga 3.0 introduced a new algorithm used for absolute positioning. This algorithm is more correct than the one previously used, but led to observed compatibility issues with existing code, so we left the option to disable it via the `AbsolutePositioningIncorrect` erratum (enabled by default in frameworks like React Native). Yoga 3.2 removes the legacy absolute positioning path, but ports over the main compatibility quirk under a new erratum `AbsolutePositionWithoutInsetsExcludesPadding` (where the previous incorrect behavior would omit padding when a position was not specified on the absolute node). Errata users should see more correct absolute positioning behavior, while preserving compatibility with existing code.
-
-## Fixed non-global YogaConfig in Java bindings
-
-Yoga would previously allow garbage collection of a `YogaConfig` if it was not retained outside of the Yoga tree. This could result in confusing errors caused by use-after free. Yoga nodes [now correctly retain the configs they are using](https://github.com/facebook/yoga/commit/22b018c957e930de950338ad87f4ef8d59e8a169). Thanks [@michaeltroger](https://github.com/michaeltroger) for this fix!
-
-## Fixed behavior when combining `align-items` with `align-content`
-
-A regression [was fixed](https://github.com/facebook/yoga/commit/77c99870127e9c2d46a07264fa372025334d8fd0) in how Yoga handles some combinations of `align-content` and `align-items`. Thanks [@phuccvx12](https://github.com/phuccvx12) for this fix!

website/docs/styling/align-content.mdx

@@ -17,15 +17,15 @@ has effect when items are wrapped to multiple lines using [flex wrap](/docs/styl
 
 **Center**: Align wrapped lines in the center of the container's cross axis.
 
-**Space between**: Evenly space wrapped lines across the container's cross axis, distributing
+**Space between**: Evenly space wrapped lines across the container's main axis, distributing
 remaining space between the lines.
 
-**Space around**: Evenly space wrapped lines across the container's cross axis, distributing
+**Space around**: Evenly space wrapped lines across the container's main axis, distributing
 remaining space around the lines. Compared to space between using
 space around will result in space being distributed to the beginning of
 the first lines and end of the last line.
 
-**Space evenly**: Evenly space wrapped lines across the container's cross axis, distributing
+**Space evenly**: Evenly space wrapped lines across the container's main axis, distributing
 remaining space around the lines. Compared to space around, space evenly will not
 double the gaps between children. The size of gaps between children and between
 the parent's edges and the first/last child will all be equal.

website/package.json

@@ -27,7 +27,7 @@
     "react": "^18.3.0",
     "react-dom": "^18.3.0",
     "react-live": "^4.1.5",
-    "yoga-layout": "0.0.0"
+    "yoga-layout": "3.2.1"
   },
   "devDependencies": {
     "@docusaurus/module-type-aliases": "3.6.0",

website/src/components/FlexStyle.ts

@@ -63,7 +63,7 @@ export type FlexStyle = {
   bottom?: number | `${number}%`;
   boxSizing?: 'border-box' | 'content-box';
   direction?: 'ltr' | 'rtl';
-  display?: 'none' | 'flex' | 'contents';
+  display?: 'none' | 'flex';
   end?: number | `${number}%`;
   flex?: number;
   flexBasis?: number | 'auto' | `${number}%`;
@@ -360,14 +360,12 @@ function direction(str?: 'ltr' | 'rtl'): Direction {
   throw new Error(`"${str}" is not a valid value for direction`);
 }
 
-function display(str?: 'none' | 'flex' | 'contents'): Display {
+function display(str?: 'none' | 'flex'): Display {
   switch (str) {
     case 'none':
       return Display.None;
     case 'flex':
       return Display.Flex;
-    case 'contents':
-      return Display.Contents;
   }
   throw new Error(`"${str}" is not a valid value for display`);
 }

website/src/components/LayoutBox.tsx

@@ -16,7 +16,6 @@ export type LayoutMetrics = {
   width: number;
   height: number;
   overflow?: 'visible' | 'hidden' | 'scroll';
-  display?: 'flex' | 'none' | 'contents';
   children?: LayoutMetrics[];
 };
 
@@ -50,11 +49,7 @@ export default function LayoutBox({metrics, depth, className}: Props) {
         position: depth === 0 ? 'relative' : 'absolute',
       }}>
       {children?.map((child, i) => (
-        <LayoutBox
+        <LayoutBox key={i} metrics={child} depth={depth + 1} />
-          key={i}
-          metrics={child}
-          depth={style.display === 'contents' ? depth : depth + 1}
-        />
       ))}
     </div>
   );

website/src/components/YogaViewer.tsx

@@ -8,12 +8,7 @@
  */
 
 import {useMemo} from 'react';
-import Yoga, {
+import Yoga, {Direction, Overflow, Node as YogaNode} from 'yoga-layout';
-  Direction,
-  Display,
-  Overflow,
-  Node as YogaNode,
-} from 'yoga-layout';
 import {FlexStyle, applyStyle} from './FlexStyle';
 import LayoutBox from './LayoutBox';
 
@@ -114,16 +109,6 @@ function metricsFromYogaNode(node: YogaNode): LayoutMetrics {
           return 'visible';
       }
     })(),
-    display: (() => {
-      switch (node.getDisplay()) {
-        case Display.Flex:
-          return 'flex';
-        case Display.None:
-          return 'none';
-        case Display.Contents:
-          return 'contents';
-      }
-    })(),
     children,
   };
 }

yoga/YGEnums.cpp

@@ -245,12 +245,6 @@ const char* YGUnitToString(const YGUnit value) {
       return "percent";
     case YGUnitAuto:
       return "auto";
-    case YGUnitMaxContent:
-      return "max-content";
-    case YGUnitFitContent:
-      return "fit-content";
-    case YGUnitStretch:
-      return "stretch";
   }
   return "unknown";
 }

yoga/YGEnums.h

@@ -131,10 +131,7 @@ YG_ENUM_DECL(
     YGUnitUndefined,
     YGUnitPoint,
     YGUnitPercent,
-    YGUnitAuto,
+    YGUnitAuto)
-    YGUnitMaxContent,
-    YGUnitFitContent,
-    YGUnitStretch)
 
 YG_ENUM_DECL(
     YGWrap,

yoga/YGNodeLayout.cpp

@@ -90,11 +90,3 @@ float YGNodeLayoutGetPadding(YGNodeConstRef node, YGEdge edge) {
   return getResolvedLayoutProperty<&LayoutResults::padding>(
       node, scopedEnum(edge));
 }
-
-float YGNodeLayoutGetRawHeight(YGNodeConstRef node) {
-  return resolveRef(node)->getLayout().rawDimension(Dimension::Height);
-}
-
-float YGNodeLayoutGetRawWidth(YGNodeConstRef node) {
-  return resolveRef(node)->getLayout().rawDimension(Dimension::Width);
-}

yoga/YGNodeLayout.h

@@ -32,14 +32,4 @@ YG_EXPORT float YGNodeLayoutGetMargin(YGNodeConstRef node, YGEdge edge);
 YG_EXPORT float YGNodeLayoutGetBorder(YGNodeConstRef node, YGEdge edge);
 YG_EXPORT float YGNodeLayoutGetPadding(YGNodeConstRef node, YGEdge edge);
 
-/**
- * Return the measured height of the node, before layout rounding
- */
-YG_EXPORT float YGNodeLayoutGetRawHeight(YGNodeConstRef node);
-
-/**
- * Return the measured width of the node, before layout rounding
- */
-YG_EXPORT float YGNodeLayoutGetRawWidth(YGNodeConstRef node);
-
 YG_EXTERN_C_END

yoga/YGNodeStyle.cpp

@@ -177,34 +177,19 @@ float YGNodeStyleGetFlexShrink(const YGNodeConstRef nodeRef) {
 
 void YGNodeStyleSetFlexBasis(const YGNodeRef node, const float flexBasis) {
   updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
-      node, StyleSizeLength::points(flexBasis));
+      node, StyleLength::points(flexBasis));
 }
 
 void YGNodeStyleSetFlexBasisPercent(
     const YGNodeRef node,
     const float flexBasisPercent) {
   updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
-      node, StyleSizeLength::percent(flexBasisPercent));
+      node, StyleLength::percent(flexBasisPercent));
 }
 
 void YGNodeStyleSetFlexBasisAuto(const YGNodeRef node) {
   updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
-      node, StyleSizeLength::ofAuto());
+      node, StyleLength::ofAuto());
-}
-
-void YGNodeStyleSetFlexBasisMaxContent(const YGNodeRef node) {
-  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
-      node, StyleSizeLength::ofMaxContent());
-}
-
-void YGNodeStyleSetFlexBasisFitContent(const YGNodeRef node) {
-  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
-      node, StyleSizeLength::ofFitContent());
-}
-
-void YGNodeStyleSetFlexBasisStretch(const YGNodeRef node) {
-  updateStyle<&Style::flexBasis, &Style::setFlexBasis>(
-      node, StyleSizeLength::ofStretch());
 }
 
 YGValue YGNodeStyleGetFlexBasis(const YGNodeConstRef node) {
@@ -293,8 +278,13 @@ void YGNodeStyleSetGapPercent(YGNodeRef node, YGGutter gutter, float percent) {
       node, scopedEnum(gutter), StyleLength::percent(percent));
 }
 
-YGValue YGNodeStyleGetGap(const YGNodeConstRef node, const YGGutter gutter) {
+float YGNodeStyleGetGap(const YGNodeConstRef node, const YGGutter gutter) {
-  return (YGValue)resolveRef(node)->style().gap(scopedEnum(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) {
@@ -318,32 +308,17 @@ YGBoxSizing YGNodeStyleGetBoxSizing(const YGNodeConstRef node) {
 
 void YGNodeStyleSetWidth(YGNodeRef node, float points) {
   updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Width, StyleSizeLength::points(points));
+      node, Dimension::Width, StyleLength::points(points));
 }
 
 void YGNodeStyleSetWidthPercent(YGNodeRef node, float percent) {
   updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Width, StyleSizeLength::percent(percent));
+      node, Dimension::Width, StyleLength::percent(percent));
 }
 
 void YGNodeStyleSetWidthAuto(YGNodeRef node) {
   updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Width, StyleSizeLength::ofAuto());
+      node, Dimension::Width, StyleLength::ofAuto());
-}
-
-void YGNodeStyleSetWidthMaxContent(YGNodeRef node) {
-  updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Width, StyleSizeLength::ofMaxContent());
-}
-
-void YGNodeStyleSetWidthFitContent(YGNodeRef node) {
-  updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Width, StyleSizeLength::ofFitContent());
-}
-
-void YGNodeStyleSetWidthStretch(YGNodeRef node) {
-  updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Width, StyleSizeLength::ofStretch());
 }
 
 YGValue YGNodeStyleGetWidth(YGNodeConstRef node) {
@@ -352,32 +327,17 @@ YGValue YGNodeStyleGetWidth(YGNodeConstRef node) {
 
 void YGNodeStyleSetHeight(YGNodeRef node, float points) {
   updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Height, StyleSizeLength::points(points));
+      node, Dimension::Height, StyleLength::points(points));
 }
 
 void YGNodeStyleSetHeightPercent(YGNodeRef node, float percent) {
   updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Height, StyleSizeLength::percent(percent));
+      node, Dimension::Height, StyleLength::percent(percent));
 }
 
 void YGNodeStyleSetHeightAuto(YGNodeRef node) {
   updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Height, StyleSizeLength::ofAuto());
+      node, Dimension::Height, StyleLength::ofAuto());
-}
-
-void YGNodeStyleSetHeightMaxContent(YGNodeRef node) {
-  updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Height, StyleSizeLength::ofMaxContent());
-}
-
-void YGNodeStyleSetHeightFitContent(YGNodeRef node) {
-  updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Height, StyleSizeLength::ofFitContent());
-}
-
-void YGNodeStyleSetHeightStretch(YGNodeRef node) {
-  updateStyle<&Style::dimension, &Style::setDimension>(
-      node, Dimension::Height, StyleSizeLength::ofStretch());
 }
 
 YGValue YGNodeStyleGetHeight(YGNodeConstRef node) {
@@ -386,27 +346,12 @@ YGValue YGNodeStyleGetHeight(YGNodeConstRef node) {
 
 void YGNodeStyleSetMinWidth(const YGNodeRef node, const float minWidth) {
   updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Width, StyleSizeLength::points(minWidth));
+      node, Dimension::Width, StyleLength::points(minWidth));
 }
 
 void YGNodeStyleSetMinWidthPercent(const YGNodeRef node, const float minWidth) {
   updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Width, StyleSizeLength::percent(minWidth));
+      node, Dimension::Width, StyleLength::percent(minWidth));
-}
-
-void YGNodeStyleSetMinWidthMaxContent(const YGNodeRef node) {
-  updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Width, StyleSizeLength::ofMaxContent());
-}
-
-void YGNodeStyleSetMinWidthFitContent(const YGNodeRef node) {
-  updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Width, StyleSizeLength::ofFitContent());
-}
-
-void YGNodeStyleSetMinWidthStretch(const YGNodeRef node) {
-  updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Width, StyleSizeLength::ofStretch());
 }
 
 YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) {
@@ -415,29 +360,14 @@ YGValue YGNodeStyleGetMinWidth(const YGNodeConstRef node) {
 
 void YGNodeStyleSetMinHeight(const YGNodeRef node, const float minHeight) {
   updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Height, StyleSizeLength::points(minHeight));
+      node, Dimension::Height, StyleLength::points(minHeight));
 }
 
 void YGNodeStyleSetMinHeightPercent(
     const YGNodeRef node,
     const float minHeight) {
   updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Height, StyleSizeLength::percent(minHeight));
+      node, Dimension::Height, StyleLength::percent(minHeight));
-}
-
-void YGNodeStyleSetMinHeightMaxContent(const YGNodeRef node) {
-  updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Height, StyleSizeLength::ofMaxContent());
-}
-
-void YGNodeStyleSetMinHeightFitContent(const YGNodeRef node) {
-  updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Height, StyleSizeLength::ofFitContent());
-}
-
-void YGNodeStyleSetMinHeightStretch(const YGNodeRef node) {
-  updateStyle<&Style::minDimension, &Style::setMinDimension>(
-      node, Dimension::Height, StyleSizeLength::ofStretch());
 }
 
 YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) {
@@ -446,27 +376,12 @@ YGValue YGNodeStyleGetMinHeight(const YGNodeConstRef node) {
 
 void YGNodeStyleSetMaxWidth(const YGNodeRef node, const float maxWidth) {
   updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Width, StyleSizeLength::points(maxWidth));
+      node, Dimension::Width, StyleLength::points(maxWidth));
 }
 
 void YGNodeStyleSetMaxWidthPercent(const YGNodeRef node, const float maxWidth) {
   updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Width, StyleSizeLength::percent(maxWidth));
+      node, Dimension::Width, StyleLength::percent(maxWidth));
-}
-
-void YGNodeStyleSetMaxWidthMaxContent(const YGNodeRef node) {
-  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Width, StyleSizeLength::ofMaxContent());
-}
-
-void YGNodeStyleSetMaxWidthFitContent(const YGNodeRef node) {
-  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Width, StyleSizeLength::ofFitContent());
-}
-
-void YGNodeStyleSetMaxWidthStretch(const YGNodeRef node) {
-  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Width, StyleSizeLength::ofStretch());
 }
 
 YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) {
@@ -475,29 +390,14 @@ YGValue YGNodeStyleGetMaxWidth(const YGNodeConstRef node) {
 
 void YGNodeStyleSetMaxHeight(const YGNodeRef node, const float maxHeight) {
   updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Height, StyleSizeLength::points(maxHeight));
+      node, Dimension::Height, StyleLength::points(maxHeight));
 }
 
 void YGNodeStyleSetMaxHeightPercent(
     const YGNodeRef node,
     const float maxHeight) {
   updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Height, StyleSizeLength::percent(maxHeight));
+      node, Dimension::Height, StyleLength::percent(maxHeight));
-}
-
-void YGNodeStyleSetMaxHeightMaxContent(const YGNodeRef node) {
-  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Height, StyleSizeLength::ofMaxContent());
-}
-
-void YGNodeStyleSetMaxHeightFitContent(const YGNodeRef node) {
-  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Height, StyleSizeLength::ofFitContent());
-}
-
-void YGNodeStyleSetMaxHeightStretch(const YGNodeRef node) {
-  updateStyle<&Style::maxDimension, &Style::setMaxDimension>(
-      node, Dimension::Height, StyleSizeLength::ofStretch());
 }
 
 YGValue YGNodeStyleGetMaxHeight(const YGNodeConstRef node) {

yoga/YGNodeStyle.h

@@ -64,9 +64,6 @@ 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 void YGNodeStyleSetFlexBasisMaxContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetFlexBasisFitContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetFlexBasisStretch(YGNodeRef node);
 YG_EXPORT YGValue YGNodeStyleGetFlexBasis(YGNodeConstRef node);
 
 YG_EXPORT void
@@ -96,7 +93,7 @@ YG_EXPORT void
 YGNodeStyleSetGap(YGNodeRef node, YGGutter gutter, float gapLength);
 YG_EXPORT void
 YGNodeStyleSetGapPercent(YGNodeRef node, YGGutter gutter, float gapLength);
-YG_EXPORT YGValue YGNodeStyleGetGap(YGNodeConstRef node, YGGutter gutter);
+YG_EXPORT float YGNodeStyleGetGap(YGNodeConstRef node, YGGutter gutter);
 
 YG_EXPORT void YGNodeStyleSetBoxSizing(YGNodeRef node, YGBoxSizing boxSizing);
 YG_EXPORT YGBoxSizing YGNodeStyleGetBoxSizing(YGNodeConstRef node);
@@ -104,45 +101,27 @@ 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 void YGNodeStyleSetWidthMaxContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetWidthFitContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetWidthStretch(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 void YGNodeStyleSetHeightMaxContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetHeightFitContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetHeightStretch(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 void YGNodeStyleSetMinWidthMaxContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetMinWidthFitContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetMinWidthStretch(YGNodeRef node);
 YG_EXPORT YGValue YGNodeStyleGetMinWidth(YGNodeConstRef node);
 
 YG_EXPORT void YGNodeStyleSetMinHeight(YGNodeRef node, float minHeight);
 YG_EXPORT void YGNodeStyleSetMinHeightPercent(YGNodeRef node, float minHeight);
-YG_EXPORT void YGNodeStyleSetMinHeightMaxContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetMinHeightFitContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetMinHeightStretch(YGNodeRef node);
 YG_EXPORT YGValue YGNodeStyleGetMinHeight(YGNodeConstRef node);
 
 YG_EXPORT void YGNodeStyleSetMaxWidth(YGNodeRef node, float maxWidth);
 YG_EXPORT void YGNodeStyleSetMaxWidthPercent(YGNodeRef node, float maxWidth);
-YG_EXPORT void YGNodeStyleSetMaxWidthMaxContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetMaxWidthFitContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetMaxWidthStretch(YGNodeRef node);
 YG_EXPORT YGValue YGNodeStyleGetMaxWidth(YGNodeConstRef node);
 
 YG_EXPORT void YGNodeStyleSetMaxHeight(YGNodeRef node, float maxHeight);
 YG_EXPORT void YGNodeStyleSetMaxHeightPercent(YGNodeRef node, float maxHeight);
-YG_EXPORT void YGNodeStyleSetMaxHeightMaxContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetMaxHeightFitContent(YGNodeRef node);
-YG_EXPORT void YGNodeStyleSetMaxHeightStretch(YGNodeRef node);
 YG_EXPORT YGValue YGNodeStyleGetMaxHeight(YGNodeConstRef node);
 
 YG_EXPORT void YGNodeStyleSetAspectRatio(YGNodeRef node, float aspectRatio);

yoga/YGValue.h

@@ -65,16 +65,13 @@ inline bool operator==(const YGValue& lhs, const YGValue& rhs) {
   switch (lhs.unit) {
     case YGUnitUndefined:
     case YGUnitAuto:
-    case YGUnitFitContent:
-    case YGUnitMaxContent:
-    case YGUnitStretch:
       return true;
     case YGUnitPoint:
     case YGUnitPercent:
       return lhs.value == rhs.value;
-    default:
-      return false;
   }
+
+  return false;
 }
 
 inline bool operator!=(const YGValue& lhs, const YGValue& rhs) {

yoga/Yoga.h

@@ -11,11 +11,11 @@
  * `#include <yoga/Yoga.h>` includes all of Yoga's public headers.
  */
 
-#include <yoga/YGConfig.h> // IWYU pragma: export
+#include <yoga/YGConfig.h>
-#include <yoga/YGEnums.h> // IWYU pragma: export
+#include <yoga/YGEnums.h>
-#include <yoga/YGMacros.h> // IWYU pragma: export
+#include <yoga/YGMacros.h>
-#include <yoga/YGNode.h> // IWYU pragma: export
+#include <yoga/YGNode.h>
-#include <yoga/YGNodeLayout.h> // IWYU pragma: export
+#include <yoga/YGNodeLayout.h>
-#include <yoga/YGNodeStyle.h> // IWYU pragma: export
+#include <yoga/YGNodeStyle.h>
-#include <yoga/YGPixelGrid.h> // IWYU pragma: export
+#include <yoga/YGPixelGrid.h>
-#include <yoga/YGValue.h> // IWYU pragma: export
+#include <yoga/YGValue.h>

yoga/algorithm/CalculateLayout.cpp

@@ -415,12 +415,6 @@ static void measureNodeWithoutChildren(
       Dimension::Height);
 }
 
-inline bool isFixedSize(float dim, SizingMode sizingMode) {
-  return sizingMode == SizingMode::StretchFit ||
-      (yoga::isDefined(dim) && sizingMode == SizingMode::FitContent &&
-       dim <= 0.0);
-}
-
 static bool measureNodeWithFixedSize(
     yoga::Node* const node,
     const Direction direction,
@@ -430,8 +424,12 @@ static bool measureNodeWithFixedSize(
     const SizingMode heightSizingMode,
     const float ownerWidth,
     const float ownerHeight) {
-  if (isFixedSize(availableWidth, widthSizingMode) &&
+  if ((yoga::isDefined(availableWidth) &&
-      isFixedSize(availableHeight, heightSizingMode)) {
+       widthSizingMode == SizingMode::FitContent && availableWidth <= 0.0f) ||
+      (yoga::isDefined(availableHeight) &&
+       heightSizingMode == SizingMode::FitContent && availableHeight <= 0.0f) ||
+      (widthSizingMode == SizingMode::StretchFit &&
+       heightSizingMode == SizingMode::StretchFit)) {
     node->setLayoutMeasuredDimension(
         boundAxis(
             node,
@@ -478,19 +476,16 @@ static void zeroOutLayoutRecursively(yoga::Node* const node) {
 }
 
 static void cleanupContentsNodesRecursively(yoga::Node* const node) {
-  if (node->hasContentsChildren()) [[unlikely]] {
+  for (auto child : node->getChildren()) {
-    node->cloneContentsChildrenIfNeeded();
+    if (child->style().display() == Display::Contents) {
-    for (auto child : node->getChildren()) {
+      child->getLayout() = {};
-      if (child->style().display() == Display::Contents) {
+      child->setLayoutDimension(0, Dimension::Width);
-        child->getLayout() = {};
+      child->setLayoutDimension(0, Dimension::Height);
-        child->setLayoutDimension(0, Dimension::Width);
+      child->setHasNewLayout(true);
-        child->setLayoutDimension(0, Dimension::Height);
+      child->setDirty(false);
-        child->setHasNewLayout(true);
+      child->cloneChildrenIfNeeded();
-        child->setDirty(false);
-        child->cloneChildrenIfNeeded();
 
-        cleanupContentsNodesRecursively(child);
+      cleanupContentsNodesRecursively(child);
-      }
     }
   }
 }
@@ -746,7 +741,7 @@ static float distributeFreeSpaceSecondPass(
           marginCross;
       const bool isLoosePercentageMeasurement =
           currentLineChild->getProcessedDimension(dimension(crossAxis))
-              .isPercent() &&
+                  .unit() == Unit::Percent &&
           sizingModeCrossDim != SizingMode::StretchFit;
       childCrossSizingMode =
           yoga::isUndefined(childCrossSize) || isLoosePercentageMeasurement
@@ -1218,10 +1213,10 @@ static void calculateLayoutImpl(
     const float ownerWidth,
     const float ownerHeight,
     const bool performLayout,
-    const LayoutPassReason reason,
     LayoutData& layoutMarkerData,
     const uint32_t depth,
-    const uint32_t generationCount) {
+    const uint32_t generationCount,
+    const LayoutPassReason reason) {
   yoga::assertFatalWithNode(
       node,
       yoga::isUndefined(availableWidth)
@@ -1785,7 +1780,7 @@ static void calculateLayoutImpl(
                                     crossAxis,
                                     direction,
                                     unclampedCrossDim,
-                                    crossAxisOwnerSize,
+                                    ownerHeight,
                                     ownerWidth) -
         paddingAndBorderAxisCross;
 
@@ -2273,10 +2268,10 @@ bool calculateLayoutInternal(
         ownerWidth,
         ownerHeight,
         performLayout,
-        reason,
         layoutMarkerData,
         depth,
-        generationCount);
+        generationCount,
+        reason);
 
     layout->lastOwnerDirection = ownerDirection;
     layout->configVersion = node->getConfig()->getVersion();

yoga/algorithm/FlexLine.cpp

@@ -17,7 +17,7 @@ FlexLine calculateFlexLine(
     yoga::Node* const node,
     const Direction ownerDirection,
     const float ownerWidth,
-    const float mainAxisOwnerSize,
+    const float mainAxisownerSize,
     const float availableInnerWidth,
     const float availableInnerMainDim,
     Node::LayoutableChildren::Iterator& iterator,
@@ -70,7 +70,7 @@ FlexLine calculateFlexLine(
             direction,
             mainAxis,
             child->getLayout().computedFlexBasis,
-            mainAxisOwnerSize,
+            mainAxisownerSize,
             ownerWidth)
             .unwrap();
 

yoga/algorithm/FlexLine.h

@@ -66,7 +66,7 @@ FlexLine calculateFlexLine(
     yoga::Node* node,
     Direction ownerDirection,
     float ownerWidth,
-    float mainAxisOwnerSize,
+    float mainAxisownerSize,
     float availableInnerWidth,
     float availableInnerMainDim,
     Node::LayoutableChildren::Iterator& iterator,

yoga/algorithm/PixelGrid.cpp

@@ -66,8 +66,7 @@ void roundLayoutResultsToPixelGrid(
     yoga::Node* const node,
     const double absoluteLeft,
     const double absoluteTop) {
-  const auto pointScaleFactor =
+  const auto pointScaleFactor = node->getConfig()->getPointScaleFactor();
-      static_cast<double>(node->getConfig()->getPointScaleFactor());
 
   const double nodeLeft = node->getLayout().position(PhysicalEdge::Left);
   const double nodeTop = node->getLayout().position(PhysicalEdge::Top);
@@ -81,7 +80,7 @@ void roundLayoutResultsToPixelGrid(
   const double absoluteNodeRight = absoluteNodeLeft + nodeWidth;
   const double absoluteNodeBottom = absoluteNodeTop + nodeHeight;
 
-  if (pointScaleFactor != 0.0) {
+  if (pointScaleFactor != 0.0f) {
     // If a node has a custom measure function we never want to round down its
     // size as this could lead to unwanted text truncation.
     const bool textRounding = node->getNodeType() == NodeType::Text;
@@ -97,34 +96,32 @@ void roundLayoutResultsToPixelGrid(
     // We multiply dimension by scale factor and if the result is close to the
     // whole number, we don't have any fraction To verify if the result is close
     // to whole number we want to check both floor and ceil numbers
-
-    const double scaledNodeWith = nodeWidth * pointScaleFactor;
     const bool hasFractionalWidth =
-        !yoga::inexactEquals(round(scaledNodeWith), scaledNodeWith);
+        !yoga::inexactEquals(fmod(nodeWidth * pointScaleFactor, 1.0), 0) &&
-
+        !yoga::inexactEquals(fmod(nodeWidth * pointScaleFactor, 1.0), 1.0);
-    const double scaledNodeHeight = nodeHeight * pointScaleFactor;
     const bool hasFractionalHeight =
-        !yoga::inexactEquals(round(scaledNodeHeight), scaledNodeHeight);
+        !yoga::inexactEquals(fmod(nodeHeight * pointScaleFactor, 1.0), 0) &&
+        !yoga::inexactEquals(fmod(nodeHeight * pointScaleFactor, 1.0), 1.0);
 
-    node->getLayout().setDimension(
+    node->setLayoutDimension(
-        Dimension::Width,
         roundValueToPixelGrid(
             absoluteNodeRight,
             pointScaleFactor,
             (textRounding && hasFractionalWidth),
             (textRounding && !hasFractionalWidth)) -
             roundValueToPixelGrid(
-                absoluteNodeLeft, pointScaleFactor, false, textRounding));
+                absoluteNodeLeft, pointScaleFactor, false, textRounding),
+        Dimension::Width);
 
-    node->getLayout().setDimension(
+    node->setLayoutDimension(
-        Dimension::Height,
         roundValueToPixelGrid(
             absoluteNodeBottom,
             pointScaleFactor,
             (textRounding && hasFractionalHeight),
             (textRounding && !hasFractionalHeight)) -
             roundValueToPixelGrid(
-                absoluteNodeTop, pointScaleFactor, false, textRounding));
+                absoluteNodeTop, pointScaleFactor, false, textRounding),
+        Dimension::Height);
   }
 
   for (yoga::Node* child : node->getChildren()) {

yoga/debug/AssertFatal.cpp

@@ -19,7 +19,6 @@ namespace facebook::yoga {
 #if defined(__cpp_exceptions)
   throw std::logic_error(message);
 #else
-  static_cast<void>(message); // Unused
   std::terminate();
 #endif
 }

yoga/enums/Unit.h

@@ -20,14 +20,11 @@ enum class Unit : uint8_t {
   Point = YGUnitPoint,
   Percent = YGUnitPercent,
   Auto = YGUnitAuto,
-  MaxContent = YGUnitMaxContent,
-  FitContent = YGUnitFitContent,
-  Stretch = YGUnitStretch,
 };
 
 template <>
 constexpr int32_t ordinalCount<Unit>() {
-  return 7;
+  return 4;
 }
 
 constexpr Unit scopedEnum(YGUnit unscoped) {

yoga/event/event.h

@@ -36,12 +36,12 @@ enum struct LayoutPassReason : int {
 };
 
 struct LayoutData {
-  int layouts = 0;
+  int layouts;
-  int measures = 0;
+  int measures;
-  uint32_t maxMeasureCache = 0;
+  uint32_t maxMeasureCache;
-  int cachedLayouts = 0;
+  int cachedLayouts;
-  int cachedMeasures = 0;
+  int cachedMeasures;
-  int measureCallbacks = 0;
+  int measureCallbacks;
   std::array<int, static_cast<uint8_t>(LayoutPassReason::COUNT)>
       measureCallbackReasonsCount;
 };

yoga/node/LayoutResults.h

@@ -66,18 +66,10 @@ struct LayoutResults {
     return measuredDimensions_[yoga::to_underlying(axis)];
   }
 
-  float rawDimension(Dimension axis) const {
-    return rawDimensions_[yoga::to_underlying(axis)];
-  }
-
   void setMeasuredDimension(Dimension axis, float dimension) {
     measuredDimensions_[yoga::to_underlying(axis)] = dimension;
   }
 
-  void setRawDimension(Dimension axis, float dimension) {
-    rawDimensions_[yoga::to_underlying(axis)] = dimension;
-  }
-
   float position(PhysicalEdge physicalEdge) const {
     return position_[yoga::to_underlying(physicalEdge)];
   }
@@ -121,7 +113,6 @@ struct LayoutResults {
 
   std::array<float, 2> dimensions_ = {{YGUndefined, YGUndefined}};
   std::array<float, 2> measuredDimensions_ = {{YGUndefined, YGUndefined}};
-  std::array<float, 2> rawDimensions_ = {{YGUndefined, YGUndefined}};
   std::array<float, 4> position_ = {};
   std::array<float, 4> margin_ = {};
   std::array<float, 4> border_ = {};

yoga/node/Node.cpp

@@ -181,17 +181,6 @@ void Node::setDirty(bool isDirty) {
   }
 }
 
-void Node::setChildren(const std::vector<Node*>& children) {
-  children_ = children;
-
-  contentsChildrenCount_ = 0;
-  for (const auto& child : children) {
-    if (child->style().display() == Display::Contents) {
-      contentsChildrenCount_++;
-    }
-  }
-}
-
 bool Node::removeChild(Node* child) {
   auto p = std::find(children_.begin(), children_.end(), child);
   if (p != children_.end()) {
@@ -256,9 +245,8 @@ void Node::setLayoutHadOverflow(bool hadOverflow) {
   layout_.setHadOverflow(hadOverflow);
 }
 
-void Node::setLayoutDimension(float lengthValue, Dimension dimension) {
+void Node::setLayoutDimension(float LengthValue, Dimension dimension) {
-  layout_.setDimension(dimension, lengthValue);
+  layout_.setDimension(dimension, LengthValue);
-  layout_.setRawDimension(dimension, lengthValue);
 }
 
 // If both left and right are defined, then use left. Otherwise return +left or
@@ -326,16 +314,16 @@ void Node::setPosition(
       crossAxisTrailingEdge);
 }
 
-Style::SizeLength Node::processFlexBasis() const {
+Style::Length Node::processFlexBasis() const {
-  Style::SizeLength flexBasis = style_.flexBasis();
+  Style::Length flexBasis = style_.flexBasis();
-  if (!flexBasis.isAuto() && !flexBasis.isUndefined()) {
+  if (flexBasis.unit() != Unit::Auto && flexBasis.unit() != Unit::Undefined) {
     return flexBasis;
   }
   if (style_.flex().isDefined() && style_.flex().unwrap() > 0.0f) {
-    return config_->useWebDefaults() ? StyleSizeLength::ofAuto()
+    return config_->useWebDefaults() ? StyleLength::ofAuto()
-                                     : StyleSizeLength::points(0);
+                                     : StyleLength::points(0);
   }
-  return StyleSizeLength::ofAuto();
+  return StyleLength::ofAuto();
 }
 
 FloatOptional Node::resolveFlexBasis(
@@ -391,23 +379,6 @@ void Node::cloneChildrenIfNeeded() {
     if (child->getOwner() != this) {
       child = resolveRef(config_->cloneNode(child, this, i));
       child->setOwner(this);
-
-      if (child->hasContentsChildren()) [[unlikely]] {
-        child->cloneContentsChildrenIfNeeded();
-      }
-    }
-    i += 1;
-  }
-}
-
-void Node::cloneContentsChildrenIfNeeded() {
-  size_t i = 0;
-  for (Node*& child : children_) {
-    if (child->style().display() == Display::Contents &&
-        child->getOwner() != this) {
-      child = resolveRef(config_->cloneNode(child, this, i));
-      child->setOwner(this);
-      child->cloneChildrenIfNeeded();
     }
     i += 1;
   }

yoga/node/Node.h

@@ -96,10 +96,6 @@ class YG_EXPORT Node : public ::YGNode {
     return config_->hasErrata(errata);
   }
 
-  bool hasContentsChildren() const {
-    return contentsChildrenCount_ != 0;
-  }
-
   YGDirtiedFunc getDirtiedFunc() const {
     return dirtiedFunc_;
   }
@@ -176,7 +172,7 @@ class YG_EXPORT Node : public ::YGNode {
     return isDirty_;
   }
 
-  Style::SizeLength getProcessedDimension(Dimension dimension) const {
+  Style::Length getProcessedDimension(Dimension dimension) const {
     return processedDimensions_[static_cast<size_t>(dimension)];
   }
 
@@ -248,19 +244,22 @@ class YG_EXPORT Node : public ::YGNode {
     owner_ = owner;
   }
 
+  void setChildren(const std::vector<Node*>& children) {
+    children_ = children;
+  }
+
   // TODO: rvalue override for setChildren
 
   void setConfig(Config* config);
 
   void setDirty(bool isDirty);
-  void setChildren(const std::vector<Node*>& children);
   void setLayoutLastOwnerDirection(Direction direction);
   void setLayoutComputedFlexBasis(FloatOptional computedFlexBasis);
   void setLayoutComputedFlexBasisGeneration(
       uint32_t computedFlexBasisGeneration);
   void setLayoutMeasuredDimension(float measuredDimension, Dimension dimension);
   void setLayoutHadOverflow(bool hadOverflow);
-  void setLayoutDimension(float lengthValue, Dimension dimension);
+  void setLayoutDimension(float LengthValue, Dimension dimension);
   void setLayoutDirection(Direction direction);
   void setLayoutMargin(float margin, PhysicalEdge edge);
   void setLayoutBorder(float border, PhysicalEdge edge);
@@ -269,7 +268,7 @@ class YG_EXPORT Node : public ::YGNode {
   void setPosition(Direction direction, float ownerWidth, float ownerHeight);
 
   // Other methods
-  Style::SizeLength processFlexBasis() const;
+  Style::Length processFlexBasis() const;
   FloatOptional resolveFlexBasis(
       Direction direction,
       FlexDirection flexDirection,
@@ -287,7 +286,6 @@ class YG_EXPORT Node : public ::YGNode {
   void removeChild(size_t index);
 
   void cloneChildrenIfNeeded();
-  void cloneContentsChildrenIfNeeded();
   void markDirtyAndPropagate();
   float resolveFlexGrow() const;
   float resolveFlexShrink() const;
@@ -324,8 +322,8 @@ class YG_EXPORT Node : public ::YGNode {
   Node* owner_ = nullptr;
   std::vector<Node*> children_;
   const Config* config_;
-  std::array<Style::SizeLength, 2> processedDimensions_{
+  std::array<Style::Length, 2> processedDimensions_{
-      {StyleSizeLength::undefined(), StyleSizeLength::undefined()}};
+      {StyleLength::undefined(), StyleLength::undefined()}};
 };
 
 inline Node* resolveRef(const YGNodeRef ref) {

yoga/style/Style.h

@@ -30,7 +30,6 @@
 #include <yoga/enums/Wrap.h>
 #include <yoga/numeric/FloatOptional.h>
 #include <yoga/style/StyleLength.h>
-#include <yoga/style/StyleSizeLength.h>
 #include <yoga/style/StyleValuePool.h>
 
 namespace facebook::yoga {
@@ -38,7 +37,6 @@ namespace facebook::yoga {
 class YG_EXPORT Style {
  public:
   using Length = StyleLength;
-  using SizeLength = StyleSizeLength;
 
   static constexpr float DefaultFlexGrow = 0.0f;
   static constexpr float DefaultFlexShrink = 0.0f;
@@ -135,10 +133,10 @@ class YG_EXPORT Style {
     pool_.store(flexShrink_, value);
   }
 
-  Style::SizeLength flexBasis() const {
+  Style::Length flexBasis() const {
-    return pool_.getSize(flexBasis_);
+    return pool_.getLength(flexBasis_);
   }
-  void setFlexBasis(Style::SizeLength value) {
+  void setFlexBasis(Style::Length value) {
     pool_.store(flexBasis_, value);
   }
 
@@ -177,17 +175,17 @@ class YG_EXPORT Style {
     pool_.store(gap_[yoga::to_underlying(gutter)], value);
   }
 
-  Style::SizeLength dimension(Dimension axis) const {
+  Style::Length dimension(Dimension axis) const {
-    return pool_.getSize(dimensions_[yoga::to_underlying(axis)]);
+    return pool_.getLength(dimensions_[yoga::to_underlying(axis)]);
   }
-  void setDimension(Dimension axis, Style::SizeLength value) {
+  void setDimension(Dimension axis, Style::Length value) {
     pool_.store(dimensions_[yoga::to_underlying(axis)], value);
   }
 
-  Style::SizeLength minDimension(Dimension axis) const {
+  Style::Length minDimension(Dimension axis) const {
-    return pool_.getSize(minDimensions_[yoga::to_underlying(axis)]);
+    return pool_.getLength(minDimensions_[yoga::to_underlying(axis)]);
   }
-  void setMinDimension(Dimension axis, Style::SizeLength value) {
+  void setMinDimension(Dimension axis, Style::Length value) {
     pool_.store(minDimensions_[yoga::to_underlying(axis)], value);
   }
 
@@ -209,10 +207,10 @@ class YG_EXPORT Style {
                                                : FloatOptional{0.0});
   }
 
-  Style::SizeLength maxDimension(Dimension axis) const {
+  Style::Length maxDimension(Dimension axis) const {
-    return pool_.getSize(maxDimensions_[yoga::to_underlying(axis)]);
+    return pool_.getLength(maxDimensions_[yoga::to_underlying(axis)]);
   }
-  void setMaxDimension(Dimension axis, Style::SizeLength value) {
+  void setMaxDimension(Dimension axis, Style::Length value) {
     pool_.store(maxDimensions_[yoga::to_underlying(axis)], value);
   }
 

yoga/style/StyleLength.h

@@ -19,11 +19,13 @@ namespace facebook::yoga {
  * 3. A CSS <length-percentage> value:
  *    a. <length> value (e.g. 10px)
  *    b. <percentage> value of a reference <length>
+ * 4. (soon) A math function which returns a <length-percentage> value
  *
  * References:
  * 1. https://www.w3.org/TR/css-values-4/#lengths
  * 2. https://www.w3.org/TR/css-values-4/#percentage-value
  * 3. https://www.w3.org/TR/css-values-4/#mixed-percentages
+ * 4. https://www.w3.org/TR/css-values-4/#math
  */
 class StyleLength {
  public:
@@ -57,14 +59,6 @@ class StyleLength {
     return unit_ == Unit::Undefined;
   }
 
-  constexpr bool isPoints() const {
-    return unit_ == Unit::Point;
-  }
-
-  constexpr bool isPercent() const {
-    return unit_ == Unit::Percent;
-  }
-
   constexpr bool isDefined() const {
     return !isUndefined();
   }
@@ -73,6 +67,10 @@ class StyleLength {
     return value_;
   }
 
+  constexpr Unit unit() const {
+    return unit_;
+  }
+
   constexpr FloatOptional resolve(float referenceLength) {
     switch (unit_) {
       case Unit::Point:
@@ -92,11 +90,6 @@ class StyleLength {
     return value_ == rhs.value_ && unit_ == rhs.unit_;
   }
 
-  constexpr bool inexactEquals(const StyleLength& other) const {
-    return unit_ == other.unit_ &&
-        facebook::yoga::inexactEquals(value_, other.value_);
-  }
-
  private:
   // We intentionally do not allow direct construction using value and unit, to
   // avoid invalid, or redundant combinations.
@@ -108,7 +101,7 @@ class StyleLength {
 };
 
 inline bool inexactEquals(const StyleLength& a, const StyleLength& b) {
-  return a.inexactEquals(b);
+  return a.unit() == b.unit() && inexactEquals(a.value(), b.value());
 }
 
 } // namespace facebook::yoga

yoga/style/StyleSizeLength.h

@@ -1,139 +0,0 @@
-/*
- * 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/enums/Unit.h>
-#include <yoga/numeric/FloatOptional.h>
-
-namespace facebook::yoga {
-
-/**
- * This class represents a CSS Value for sizes (e.g. width, height, min-width,
- * etc.). It may be one of:
- * 1. Undefined
- * 2. A keyword (e.g. auto, max-content, stretch, etc.)
- * 3. A CSS <length-percentage> value:
- *    a. <length> value (e.g. 10px)
- *    b. <percentage> value of a reference <length>
- *
- * References:
- * 1. https://www.w3.org/TR/css-values-4/#lengths
- * 2. https://www.w3.org/TR/css-values-4/#percentage-value
- * 3. https://www.w3.org/TR/css-values-4/#mixed-percentages
- */
-class StyleSizeLength {
- public:
-  constexpr StyleSizeLength() = default;
-
-  constexpr static StyleSizeLength points(float value) {
-    return yoga::isUndefined(value) || yoga::isinf(value)
-        ? undefined()
-        : StyleSizeLength{FloatOptional{value}, Unit::Point};
-  }
-
-  constexpr static StyleSizeLength percent(float value) {
-    return yoga::isUndefined(value) || yoga::isinf(value)
-        ? undefined()
-        : StyleSizeLength{FloatOptional{value}, Unit::Percent};
-  }
-
-  constexpr static StyleSizeLength ofAuto() {
-    return StyleSizeLength{{}, Unit::Auto};
-  }
-
-  constexpr static StyleSizeLength ofMaxContent() {
-    return StyleSizeLength{{}, Unit::MaxContent};
-  }
-
-  constexpr static StyleSizeLength ofFitContent() {
-    return StyleSizeLength{{}, Unit::FitContent};
-  }
-
-  constexpr static StyleSizeLength ofStretch() {
-    return StyleSizeLength{{}, Unit::Stretch};
-  }
-
-  constexpr static StyleSizeLength undefined() {
-    return StyleSizeLength{{}, Unit::Undefined};
-  }
-
-  constexpr bool isAuto() const {
-    return unit_ == Unit::Auto;
-  }
-
-  constexpr bool isMaxContent() const {
-    return unit_ == Unit::MaxContent;
-  }
-
-  constexpr bool isFitContent() const {
-    return unit_ == Unit::FitContent;
-  }
-
-  constexpr bool isStretch() const {
-    return unit_ == Unit::Stretch;
-  }
-
-  constexpr bool isUndefined() const {
-    return unit_ == Unit::Undefined;
-  }
-
-  constexpr bool isDefined() const {
-    return !isUndefined();
-  }
-
-  constexpr bool isPoints() const {
-    return unit_ == Unit::Point;
-  }
-
-  constexpr bool isPercent() const {
-    return unit_ == Unit::Percent;
-  }
-
-  constexpr FloatOptional value() const {
-    return value_;
-  }
-
-  constexpr FloatOptional resolve(float referenceLength) {
-    switch (unit_) {
-      case Unit::Point:
-        return value_;
-      case Unit::Percent:
-        return FloatOptional{value_.unwrap() * referenceLength * 0.01f};
-      default:
-        return FloatOptional{};
-    }
-  }
-
-  explicit constexpr operator YGValue() const {
-    return YGValue{value_.unwrap(), unscopedEnum(unit_)};
-  }
-
-  constexpr bool operator==(const StyleSizeLength& rhs) const {
-    return value_ == rhs.value_ && unit_ == rhs.unit_;
-  }
-
-  constexpr bool inexactEquals(const StyleSizeLength& other) const {
-    return unit_ == other.unit_ &&
-        facebook::yoga::inexactEquals(value_, other.value_);
-  }
-
- private:
-  // We intentionally do not allow direct construction using value and unit, to
-  // avoid invalid, or redundant combinations.
-  constexpr StyleSizeLength(FloatOptional value, Unit unit)
-      : value_(value), unit_(unit) {}
-
-  FloatOptional value_{};
-  Unit unit_{Unit::Undefined};
-};
-
-inline bool inexactEquals(const StyleSizeLength& a, const StyleSizeLength& b) {
-  return a.inexactEquals(b);
-}
-
-} // namespace facebook::yoga

yoga/style/StyleValueHandle.h

@@ -62,16 +62,8 @@ class StyleValueHandle {
     Percent,
     Number,
     Auto,
-    Keyword
   };
 
-  // Intentionally leaving out auto as a fast path
-  enum class Keyword : uint8_t { MaxContent, FitContent, Stretch };
-
-  constexpr bool isKeyword(Keyword keyword) const {
-    return type() == Type::Keyword && value() == static_cast<uint16_t>(keyword);
-  }
-
   constexpr Type type() const {
     return static_cast<Type>(repr_ & kHandleTypeMask);
   }

yoga/style/StyleValuePool.h

@@ -13,7 +13,6 @@
 #include <yoga/numeric/FloatOptional.h>
 #include <yoga/style/SmallValueBuffer.h>
 #include <yoga/style/StyleLength.h>
-#include <yoga/style/StyleSizeLength.h>
 #include <yoga/style/StyleValueHandle.h>
 
 namespace facebook::yoga {
@@ -33,30 +32,13 @@ class StyleValuePool {
     } else if (length.isAuto()) {
       handle.setType(StyleValueHandle::Type::Auto);
     } else {
-      auto type = length.isPoints() ? StyleValueHandle::Type::Point
+      auto type = length.unit() == Unit::Point
-                                    : StyleValueHandle::Type::Percent;
+          ? StyleValueHandle::Type::Point
+          : StyleValueHandle::Type::Percent;
       storeValue(handle, length.value().unwrap(), type);
     }
   }
 
-  void store(StyleValueHandle& handle, StyleSizeLength sizeValue) {
-    if (sizeValue.isUndefined()) {
-      handle.setType(StyleValueHandle::Type::Undefined);
-    } else if (sizeValue.isAuto()) {
-      handle.setType(StyleValueHandle::Type::Auto);
-    } else if (sizeValue.isMaxContent()) {
-      storeKeyword(handle, StyleValueHandle::Keyword::MaxContent);
-    } else if (sizeValue.isStretch()) {
-      storeKeyword(handle, StyleValueHandle::Keyword::Stretch);
-    } else if (sizeValue.isFitContent()) {
-      storeKeyword(handle, StyleValueHandle::Keyword::FitContent);
-    } else {
-      auto type = sizeValue.isPoints() ? StyleValueHandle::Type::Point
-                                       : StyleValueHandle::Type::Percent;
-      storeValue(handle, sizeValue.value().unwrap(), type);
-    }
-  }
-
   void store(StyleValueHandle& handle, FloatOptional number) {
     if (number.isUndefined()) {
       handle.setType(StyleValueHandle::Type::Undefined);
@@ -84,31 +66,6 @@ class StyleValuePool {
     }
   }
 
-  StyleSizeLength getSize(StyleValueHandle handle) const {
-    if (handle.isUndefined()) {
-      return StyleSizeLength::undefined();
-    } else if (handle.isAuto()) {
-      return StyleSizeLength::ofAuto();
-    } else if (handle.isKeyword(StyleValueHandle::Keyword::MaxContent)) {
-      return StyleSizeLength::ofMaxContent();
-    } else if (handle.isKeyword(StyleValueHandle::Keyword::FitContent)) {
-      return StyleSizeLength::ofFitContent();
-    } else if (handle.isKeyword(StyleValueHandle::Keyword::Stretch)) {
-      return StyleSizeLength::ofStretch();
-    } else {
-      assert(
-          handle.type() == StyleValueHandle::Type::Point ||
-          handle.type() == StyleValueHandle::Type::Percent);
-      float value = (handle.isValueIndexed())
-          ? std::bit_cast<float>(buffer_.get32(handle.value()))
-          : unpackInlineInteger(handle.value());
-
-      return handle.type() == StyleValueHandle::Type::Point
-          ? StyleSizeLength::points(value)
-          : StyleSizeLength::percent(value);
-    }
-  }
-
   FloatOptional getNumber(StyleValueHandle handle) const {
     if (handle.isUndefined()) {
       return FloatOptional{};
@@ -141,20 +98,6 @@ class StyleValuePool {
     }
   }
 
-  void storeKeyword(
-      StyleValueHandle& handle,
-      StyleValueHandle::Keyword keyword) {
-    handle.setType(StyleValueHandle::Type::Keyword);
-
-    if (handle.isValueIndexed()) {
-      auto newIndex =
-          buffer_.replace(handle.value(), static_cast<uint32_t>(keyword));
-      handle.setValue(newIndex);
-    } else {
-      handle.setValue(static_cast<uint16_t>(keyword));
-    }
-  }
-
   static constexpr bool isIntegerPackable(float f) {
     constexpr uint16_t kMaxInlineAbsValue = (1 << 11) - 1;