1.8.0

Summary: New release. Reviewed By: marco-cova Differential Revision: D7550852 fbshipit-source-id: eac5662179daa88d9d62c55566b3a31428c4117a
[yoga re-add assertion to check for owner reference before adding child.
2018-04-09 02:41:21 -07:00 · 2018-04-04 10:57:52 -07:00 · 2018-04-04 09:55:45 -07:00 · 2018-04-04 08:29:43 -07:00 · 2018-04-04 08:29:43 -07:00 · 2018-04-04 08:29:43 -07:00
36 changed files with 1868 additions and 949 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,10 +1,3 @@
-# Copyright (c) 2014-present, Facebook, Inc.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree. An additional grant
-# of patent rights can be found in the PATENTS file in the same directory.
-
 language: node_js
 node_js:
  - "8"
--- a/14
+++ b/14
@@ -32,20 +32,6 @@ cxx_library(
    ],
 )

-cxx_library(
-    name = "yogafastmath",
-    srcs = glob(["yoga/*.cpp"]),
-    header_namespace = "",
-    exported_headers = subdir_glob([("", "yoga/*.h")]),
-    compiler_flags = COMPILER_FLAGS + ["-ffast-math"],
-    soname = "libyogafastmathcore.$(ext)",
-    tests = [":YogaTests"],
-    visibility = ["PUBLIC"],
-    deps = [
-        yoga_dep("lib/fb:ndklog"),
-    ],
-)
-
 cxx_test(
    name = "YogaTests",
    srcs = glob(["tests/*.cpp"]),
--- a/Yoga.podspec
+++ b/Yoga.podspec
@@ -1,9 +1,9 @@
 Pod::Spec.new do |spec|
  spec.name = 'Yoga'
-  spec.version = '1.7.0'
+  spec.version = '1.8.0'
  spec.license =  { :type => 'MIT', :file => "LICENSE" }
-  spec.homepage = 'https://facebook.github.io/yoga/'
-  spec.documentation_url = 'https://facebook.github.io/yoga/docs/api/c/'
+  spec.homepage = 'https://yogalayout.com/'
+  spec.documentation_url = 'https://yogalayout.com/docs'

  spec.summary = 'Yoga is a cross-platform layout engine which implements Flexbox.'
  spec.description = 'Yoga is a cross-platform layout engine enabling maximum collaboration within your team by implementing an API many designers are familiar with, and opening it up to developers across different platforms.'
@@ -11,9 +11,9 @@ Pod::Spec.new do |spec|
  spec.authors = 'Facebook'
  spec.source = {
    :git => 'https://github.com/facebook/yoga.git',
-    :tag => '1.7.0',
+    :tag => '1.8.0',
  }
-
+  spec.osx.deployment_target  = '10.13'
  spec.module_name = 'yoga'
  spec.requires_arc = false
  spec.compiler_flags = [
@@ -25,4 +25,6 @@ Pod::Spec.new do |spec|
      '-fPIC'
  ]
  spec.source_files = 'yoga/**/*.{c,h,cpp}'
+  spec.public_header_files = 'yoga/{Yoga,YGEnums,YGMacros}.h'
+
 end
--- a/android/sample/java/com/facebook/samples/yoga/BUCK
+++ b/android/sample/java/com/facebook/samples/yoga/BUCK
@@ -1,9 +1,7 @@
 # Copyright (c) 2014-present, Facebook, Inc.
-# All rights reserved.
 #
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree. An additional grant
-# of patent rights can be found in the PATENTS file in the same directory.
+# This source code is licensed under the license found in the
+# LICENSE-examples file in the root directory of this source tree.

 load("//:yoga_defs.bzl", "ANDROID_JAVA_TARGET", "ANDROID_SAMPLE_RES_TARGET", "ANDROID_SUPPORT_TARGET", "APPCOMPAT_TARGET", "SOLOADER_TARGET", "android_library")

--- a/android/src/main/java/com/facebook/yoga/android/YogaLayout.java
+++ b/android/src/main/java/com/facebook/yoga/android/YogaLayout.java
@@ -7,9 +7,6 @@

 package com.facebook.yoga.android;

-import java.util.HashMap;
-import java.util.Map;
-
 import android.content.Context;
 import android.content.res.Configuration;
 import android.content.res.TypedArray;
@@ -21,9 +18,6 @@ import android.util.SparseArray;
 import android.util.TypedValue;
 import android.view.View;
 import android.view.ViewGroup;
-import android.util.Log;
-
-import com.facebook.yoga.android.R;
 import com.facebook.yoga.YogaAlign;
 import com.facebook.yoga.YogaConstants;
 import com.facebook.yoga.YogaDirection;
@@ -35,10 +29,11 @@ import com.facebook.yoga.YogaMeasureFunction;
 import com.facebook.yoga.YogaMeasureMode;
 import com.facebook.yoga.YogaMeasureOutput;
 import com.facebook.yoga.YogaNode;
-import com.facebook.yoga.YogaNode;
 import com.facebook.yoga.YogaOverflow;
 import com.facebook.yoga.YogaPositionType;
 import com.facebook.yoga.YogaWrap;
+import java.util.HashMap;
+import java.util.Map;

 /**
 * A {@code ViewGroup} based on the Yoga layout engine.
@@ -51,14 +46,14 @@ import com.facebook.yoga.YogaWrap;
 * <YogaLayout
 *     xmlns:android="http://schemas.android.com/apk/res/android"
 *     xmlns:yoga="http://schemas.android.com/apk/com.facebook.yoga.android"
- *     android:layout_width="match_parent"
- *     android:layout_height="match_parent"
+ *     android:layout_width="match_owner"
+ *     android:layout_height="match_owner"
 *     yoga:flex_direction="row"
 *     yoga:padding_all="10dp"
 *     >
 *     <TextView
- *         android:layout_width="match_parent"
- *         android:layout_height="match_parent"
+ *         android:layout_width="match_owner"
+ *         android:layout_height="match_owner"
 *         android:text="Hello, World!"
 *         yoga:flex="1"
 *         />
@@ -267,11 +262,11 @@ public class YogaLayout extends ViewGroup {
      return;
    }

-    final YogaNode parent = node.getParent();
+    final YogaNode owner = node.getOwner();

-    for (int i = 0; i < parent.getChildCount(); i++) {
-      if (parent.getChildAt(i).equals(node)) {
-        parent.removeChildAt(i);
+    for (int i = 0; i < owner.getChildCount(); i++) {
+      if (owner.getChildAt(i).equals(node)) {
+        owner.removeChildAt(i);
        break;
      }
    }
@@ -291,6 +286,8 @@ public class YogaLayout extends ViewGroup {
      if (view.getVisibility() == GONE) {
        return;
      }
+      int left = Math.round(xOffset + node.getLayoutX());
+      int top = Math.round(yOffset + node.getLayoutY());
      view.measure(
          View.MeasureSpec.makeMeasureSpec(
              Math.round(node.getLayoutWidth()),
@@ -298,11 +295,7 @@ public class YogaLayout extends ViewGroup {
          View.MeasureSpec.makeMeasureSpec(
              Math.round(node.getLayoutHeight()),
              View.MeasureSpec.EXACTLY));
-      view.layout(
-          Math.round(xOffset + node.getLayoutX()),
-          Math.round(yOffset + node.getLayoutY()),
-          Math.round(xOffset + node.getLayoutX() + node.getLayoutWidth()),
-          Math.round(yOffset + node.getLayoutY() + node.getLayoutHeight()));
+      view.layout(left, top, left + view.getMeasuredWidth(), top + view.getMeasuredHeight());
    }

    final int childrenCount = node.getChildCount();
@@ -322,7 +315,7 @@ public class YogaLayout extends ViewGroup {

  @Override
  protected void onLayout(boolean changed, int l, int t, int r, int b) {
-    // Either we are a root of a tree, or this function is called by our parent's onLayout, in which
+    // Either we are a root of a tree, or this function is called by our owner's onLayout, in which
    // case our r-l and b-t are the size of our node.
    if (!(getParent() instanceof YogaLayout)) {
        createLayout(
@@ -706,7 +699,7 @@ public class YogaLayout extends ViewGroup {
    /**
     * Constructs a set of layout params, given width and height specs.  In this case, we can set
     * the {@code yoga:width} and {@code yoga:height} if we are given them explicitly.  If other
-     * options (such as {@code match_parent} or {@code wrap_content} are given, then the parent
+     * options (such as {@code match_owner} or {@code wrap_content} are given, then the owner
     * LayoutParams will store them, and we deal with them during layout. (see
     * {@link YogaLayout#createLayout})
     *
@@ -780,9 +773,9 @@ public class YogaLayout extends ViewGroup {
     * {@code View}'s measure function.
     *
     * @param node The yoga node to measure
-     * @param width The suggested width from the parent
+     * @param width The suggested width from the owner
     * @param widthMode The type of suggestion for the width
-     * @param height The suggested height from the parent
+     * @param height The suggested height from the owner
     * @param heightMode The type of suggestion for the height
     * @return A measurement output ({@code YogaMeasureOutput}) for the node
     */
--- a/csharp/Yoga/Yoga.vcxproj
+++ b/csharp/Yoga/Yoga.vcxproj
@@ -227,19 +227,31 @@
    </Link>
  </ItemDefinitionGroup>
  <ItemGroup>
-    <ClInclude Include="..\..\yoga\Yoga.h" />
+    <ClInclude Include="..\..\yoga\Utils.h" />
+    <ClInclude Include="..\..\yoga\YGConfig.h" />
    <ClInclude Include="..\..\yoga\YGEnums.h" />
+    <ClInclude Include="..\..\yoga\YGFloatOptional.h" />
+    <ClInclude Include="..\..\yoga\YGLayout.h" />
    <ClInclude Include="..\..\yoga\YGMacros.h" />
-    <ClInclude Include="..\..\yoga\YGNodeList.h" />
+    <ClInclude Include="..\..\yoga\YGNode.h" />
+    <ClInclude Include="..\..\yoga\YGNodePrint.h" />
+    <ClInclude Include="..\..\yoga\YGStyle.h" />
+    <ClInclude Include="..\..\yoga\Yoga-internal.h" />
+    <ClInclude Include="..\..\yoga\Yoga.h" />
    <ClInclude Include="resource.h" />
-    <ClInclude Include="YGInterop.h" />
    <ClInclude Include="stdafx.h" />
    <ClInclude Include="targetver.h" />
  </ItemGroup>
  <ItemGroup>
-    <ClCompile Include="..\..\yoga\Yoga.c" />
-    <ClCompile Include="..\..\yoga\YGEnums.c" />
-    <ClCompile Include="..\..\yoga\YGNodeList.c" />
+    <ClCompile Include="..\..\yoga\Utils.cpp" />
+    <ClCompile Include="..\..\yoga\YGConfig.cpp" />
+    <ClCompile Include="..\..\yoga\YGEnums.cpp" />
+    <ClCompile Include="..\..\yoga\YGFloatOptional.cpp" />
+    <ClCompile Include="..\..\yoga\YGLayout.cpp" />
+    <ClCompile Include="..\..\yoga\YGNode.cpp" />
+    <ClCompile Include="..\..\yoga\YGNodePrint.cpp" />
+    <ClCompile Include="..\..\yoga\YGStyle.cpp" />
+    <ClCompile Include="..\..\yoga\Yoga.cpp" />
    <ClCompile Include="YGInterop.cpp" />
    <ClCompile Include="dllmain.cpp">
      <CompileAsManaged Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</CompileAsManaged>
--- a/csharp/Yoga/Yoga.vcxproj.filters
+++ b/csharp/Yoga/Yoga.vcxproj.filters
@@ -21,19 +21,40 @@
    <ClInclude Include="targetver.h">
      <Filter>Header Files</Filter>
    </ClInclude>
-    <ClInclude Include="..\..\yoga\Yoga.h">
+    <ClInclude Include="resource.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\yoga\Utils.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\yoga\YGEnums.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\yoga\YGFloatOptional.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\yoga\YGLayout.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="..\..\yoga\YGMacros.h">
      <Filter>Header Files</Filter>
    </ClInclude>
-    <ClInclude Include="..\..\yoga\YGNodeList.h">
+    <ClInclude Include="..\..\yoga\YGNode.h">
      <Filter>Header Files</Filter>
    </ClInclude>
-    <ClInclude Include="YGInterop.h">
+    <ClInclude Include="..\..\yoga\YGNodePrint.h">
      <Filter>Header Files</Filter>
    </ClInclude>
-    <ClInclude Include="resource.h">
+    <ClInclude Include="..\..\yoga\YGStyle.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\yoga\Yoga.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\yoga\Yoga-internal.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\yoga\YGConfig.h">
      <Filter>Header Files</Filter>
    </ClInclude>
  </ItemGroup>
@@ -44,15 +65,36 @@
    <ClCompile Include="dllmain.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
-    <ClCompile Include="..\..\yoga\Yoga.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\yoga\YGNodeList.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
    <ClCompile Include="YGInterop.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
+    <ClCompile Include="..\..\yoga\Utils.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\yoga\YGEnums.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\yoga\YGFloatOptional.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\yoga\YGLayout.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\yoga\YGNode.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\yoga\YGNodePrint.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\yoga\YGStyle.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\yoga\Yoga.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\yoga\YGConfig.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="Yoga.rc">
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,7 +2,7 @@

 org.gradle.jvmargs=-Xmx1536M

-VERSION_NAME=1.7.1-SNAPSHOT
+VERSION_NAME=1.8.0
 POM_URL=https://github.com/facebook/yoga
 POM_SCM_URL=https://github.com/facebook/yoga.git
 POM_SCM_CONNECTION=scm:git:https://github.com/facebook/yoga.git
--- a/java/BUCK
+++ b/java/BUCK
@@ -28,29 +28,6 @@ cxx_library(
    ],
 )

-cxx_library(
-    name = "jniFastMath",
-    srcs = glob(["jni/*.cpp"]),
-    header_namespace = "",
-    compiler_flags = [
-        "-fno-omit-frame-pointer",
-        "-fexceptions",
-        "-fPIC",
-        "-Wall",
-        "-Werror",
-        "-O3",
-        "-std=c++11",
-    ],
-    platforms = ANDROID,
-    soname = "libyogafastmath.$(ext)",
-    visibility = ["PUBLIC"],
-    deps = [
-        FBJNI_TARGET,
-        JNI_TARGET,
-        yoga_dep(":yogafastmath"),
-    ],
-)
-
 java_library(
    name = "java",
    srcs = glob(["com/facebook/yoga/*.java"]),
@@ -63,7 +40,6 @@ java_library(
    visibility = ["PUBLIC"],
    deps = [
        ":jni",
-        ":jniFastMath",
        INFER_ANNOTATIONS_TARGET,
        JSR_305_TARGET,
        PROGRUARD_ANNOTATIONS_TARGET,
--- a/java/com/facebook/yoga/YogaConfig.java
+++ b/java/com/facebook/yoga/YogaConfig.java
@@ -16,16 +16,12 @@ public class YogaConfig {
  public static int SPACING_TYPE = 1;

  static {
-    if (YogaConstants.shouldUseFastMath) {
-      SoLoader.loadLibrary("yogafastmath");
-    } else {
      SoLoader.loadLibrary("yoga");
-    }
  }

  long mNativePointer;
  private YogaLogger mLogger;
-  private YogaNodeClonedFunction mNodeClonedFunction;
+  private YogaNodeCloneFunction mYogaNodeCloneFunction;

  private native long jni_YGConfigNew();
  public YogaConfig() {
@@ -74,6 +70,19 @@ public class YogaConfig {
    jni_YGConfigSetUseLegacyStretchBehaviour(mNativePointer, useLegacyStretchBehaviour);
  }

+  private native void jni_YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
+      long nativePointer, boolean shouldDiffLayoutWithoutLegacyStretchBehaviour);
+  /**
+   * If this flag is set then yoga would diff the layout without legacy flag and would set a bool in
+   * YogaNode(mDoesLegacyStretchFlagAffectsLayout) with true if the layouts were different and false
+   * if not
+   */
+  public void setShouldDiffLayoutWithoutLegacyStretchBehaviour(
+      boolean shouldDiffLayoutWithoutLegacyStretchBehaviour) {
+    jni_YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
+        mNativePointer, shouldDiffLayoutWithoutLegacyStretchBehaviour);
+  }
+
  private native void jni_YGConfigSetLogger(long nativePointer, Object logger);
  public void setLogger(YogaLogger logger) {
    mLogger = logger;
@@ -84,16 +93,15 @@ public class YogaConfig {
    return mLogger;
  }

-  private native void jni_YGConfigSetHasNodeClonedFunc(long nativePointer, boolean hasClonedFunc);
+  private native void jni_YGConfigSetHasCloneNodeFunc(long nativePointer, boolean hasClonedFunc);

-  public void setOnNodeCloned(YogaNodeClonedFunction nodeClonedFunction) {
-    mNodeClonedFunction = nodeClonedFunction;
-    jni_YGConfigSetHasNodeClonedFunc(mNativePointer, nodeClonedFunction != null);
+  public void setOnCloneNode(YogaNodeCloneFunction cloneYogaNodeFunction) {
+    mYogaNodeCloneFunction = cloneYogaNodeFunction;
+    jni_YGConfigSetHasCloneNodeFunc(mNativePointer, cloneYogaNodeFunction != null);
  }

  @DoNotStrip
-  public final void onNodeCloned(
-      YogaNode oldNode, YogaNode newNode, YogaNode parent, int childIndex) {
-    mNodeClonedFunction.onNodeCloned(oldNode, newNode, parent, childIndex);
+  private final YogaNode cloneNode(YogaNode oldNode, YogaNode parent, int childIndex) {
+    return mYogaNodeCloneFunction.cloneNode(oldNode, parent, childIndex);
  }
 }
--- a/java/com/facebook/yoga/YogaConstants.java
+++ b/java/com/facebook/yoga/YogaConstants.java
@@ -18,8 +18,6 @@ public class YogaConstants {
   */
  public static final float UNDEFINED = (float) (10E20);

-  public static boolean shouldUseFastMath = false;
-
  public static boolean isUndefined(float value) {
    // Value of a float in the case of it being not defined is 10.1E20. Earlier it used to be NAN,
    // the benefit of which
--- a/java/com/facebook/yoga/YogaNode.java
+++ b/java/com/facebook/yoga/YogaNode.java
@@ -17,11 +17,7 @@ import javax.annotation.Nullable;
 public class YogaNode implements Cloneable {

  static {
-    if (YogaConstants.shouldUseFastMath) {
-      SoLoader.loadLibrary("yogafastmath");
-    } else {
      SoLoader.loadLibrary("yoga");
-    }
  }

  /**
@@ -29,8 +25,8 @@ public class YogaNode implements Cloneable {
   */
  static native int jni_YGNodeGetInstanceCount();

-  private YogaNode mParent;
-  private List<YogaNode> mChildren;
+  private YogaNode mOwner;
+  @Nullable private List<YogaNode> mChildren;
  private YogaMeasureFunction mMeasureFunction;
  private YogaBaselineFunction mBaselineFunction;
  private long mNativePointer;
@@ -82,6 +78,7 @@ public class YogaNode implements Cloneable {
  private int mLayoutDirection = 0;
  @DoNotStrip
  private boolean mHasNewLayout = true;
+  @DoNotStrip private boolean mDoesLegacyStretchFlagAffectsLayout = false;

  private native long jni_YGNodeNew();
  public YogaNode() {
@@ -136,6 +133,7 @@ public class YogaNode implements Cloneable {
    mMeasureFunction = null;
    mBaselineFunction = null;
    mData = null;
+    mDoesLegacyStretchFlagAffectsLayout = false;

    jni_YGNodeReset(mNativePointer);
  }
@@ -145,12 +143,15 @@ public class YogaNode implements Cloneable {
  }

  public YogaNode getChildAt(int i) {
+    if (mChildren == null) {
+      throw new IllegalStateException("YogaNode does not have children");
+    }
    return mChildren.get(i);
  }

  private native void jni_YGNodeInsertChild(long nativePointer, long childPointer, int index);
  public void addChildAt(YogaNode child, int i) {
-    if (child.mParent != null) {
+    if (child.mOwner != null) {
      throw new IllegalStateException("Child already has a parent, it must be removed first.");
    }

@@ -158,35 +159,84 @@ public class YogaNode implements Cloneable {
      mChildren = new ArrayList<>(4);
    }
    mChildren.add(i, child);
-    child.mParent = this;
+    child.mOwner = this;
    jni_YGNodeInsertChild(mNativePointer, child.mNativePointer, i);
  }

+  private native void jni_YGNodeInsertSharedChild(long nativePointer, long childPointer, int index);
+
+  public void addSharedChildAt(YogaNode child, int i) {
+    if (mChildren == null) {
+      mChildren = new ArrayList<>(4);
+    }
+    mChildren.add(i, child);
+    child.mOwner = null;
+    jni_YGNodeInsertSharedChild(mNativePointer, child.mNativePointer, i);
+  }
+
  private native long jni_YGNodeClone(long nativePointer, Object newNode);

  @Override
-  public YogaNode clone() throws CloneNotSupportedException {
-    YogaNode clonedYogaNode = (YogaNode) super.clone();
-    long clonedNativePointer = jni_YGNodeClone(mNativePointer, clonedYogaNode);
-    clonedYogaNode.mNativePointer = clonedNativePointer;
-    clonedYogaNode.mChildren =
-        mChildren != null ? (List<YogaNode>) ((ArrayList) mChildren).clone() : null;
-    return clonedYogaNode;
+  public YogaNode clone() {
+    try {
+      YogaNode clonedYogaNode = (YogaNode) super.clone();
+      long clonedNativePointer = jni_YGNodeClone(mNativePointer, clonedYogaNode);
+      clonedYogaNode.mNativePointer = clonedNativePointer;
+      clonedYogaNode.mOwner = null;
+      clonedYogaNode.mChildren =
+          mChildren != null ? (List<YogaNode>) ((ArrayList) mChildren).clone() : null;
+      return clonedYogaNode;
+    } catch (CloneNotSupportedException ex) {
+      // This class implements Cloneable, this should not happen
+      throw new RuntimeException(ex);
+    }
+  }
+
+  public YogaNode cloneWithNewChildren() {
+    try {
+      YogaNode clonedYogaNode = (YogaNode) super.clone();
+      long clonedNativePointer = jni_YGNodeClone(mNativePointer, clonedYogaNode);
+      clonedYogaNode.mOwner = null;
+      clonedYogaNode.mNativePointer = clonedNativePointer;
+      clonedYogaNode.clearChildren();
+      return clonedYogaNode;
+    } catch (CloneNotSupportedException ex) {
+      // This class implements Cloneable, this should not happen
+      throw new RuntimeException(ex);
+    }
+  }
+
+  private native void jni_YGNodeClearChildren(long nativePointer);
+
+  private void clearChildren() {
+    mChildren = null;
+    jni_YGNodeClearChildren(mNativePointer);
  }

  private native void jni_YGNodeRemoveChild(long nativePointer, long childPointer);
  public YogaNode removeChildAt(int i) {
-
+    if (mChildren == null) {
+      throw new IllegalStateException(
+          "Trying to remove a child of a YogaNode that does not have children");
+    }
    final YogaNode child = mChildren.remove(i);
-    child.mParent = null;
+    child.mOwner = null;
    jni_YGNodeRemoveChild(mNativePointer, child.mNativePointer);
    return child;
  }

+  /**
+   * @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
-  YogaNode getParent() {
-    return mParent;
+  YogaNode getOwner() {
+    return mOwner;
  }

  public int indexOf(YogaNode child) {
@@ -573,6 +623,10 @@ public class YogaNode implements Cloneable {
    return mHeight;
  }

+  public boolean getDoesLegacyStretchFlagAffectsLayout() {
+    return mDoesLegacyStretchFlagAffectsLayout;
+  }
+
  public float getLayoutMargin(YogaEdge edge) {
    switch (edge) {
      case LEFT:
@@ -691,4 +745,22 @@ public class YogaNode implements Cloneable {
  public void print() {
    jni_YGNodePrint(mNativePointer);
  }
+
+  /**
+   * This method replaces the child at childIndex position with the newNode received by parameter.
+   * This is different than calling removeChildAt and addChildAt because this method ONLY replaces
+   * the child in the mChildren datastructure. @DoNotStrip: called from JNI
+   *
+   * @return the nativePointer of the newNode {@linl YogaNode}
+   */
+  @DoNotStrip
+  private final long replaceChild(YogaNode newNode, int childIndex) {
+    if (mChildren == null) {
+      throw new IllegalStateException("Cannot replace child. YogaNode does not have children");
+    }
+    mChildren.remove(childIndex);
+    mChildren.add(childIndex, newNode);
+    newNode.mOwner = this;
+    return newNode.mNativePointer;
+  }
 }
--- a/java/com/facebook/yoga/YogaNodeClonedFunction.java
+++ b/java/com/facebook/yoga/YogaNodeClonedFunction.java
@@ -10,8 +10,8 @@ package com.facebook.yoga;
 import com.facebook.proguard.annotations.DoNotStrip;

@DoNotStrip
-public interface YogaNodeClonedFunction {
+public interface YogaNodeCloneFunction {

  @DoNotStrip
-  void onNodeCloned(YogaNode oldNode, YogaNode newNode, YogaNode parent, int childIndex);
+  YogaNode cloneNode(YogaNode oldNode, YogaNode parent, int childIndex);
 }
--- a/java/jni/YGJNI.cpp
+++ b/java/jni/YGJNI.cpp
@@ -67,6 +67,9 @@ static void YGTransferLayoutOutputsRecursive(YGNodeRef root) {

      static auto edgeSetFlagField = obj->getClass()->getField<jint>("mEdgeSetFlag");
      static auto hasNewLayoutField = obj->getClass()->getField<jboolean>("mHasNewLayout");
+      static auto doesLegacyStretchBehaviour =
+          obj->getClass()->getField<jboolean>(
+              "mDoesLegacyStretchFlagAffectsLayout");

      /* Those flags needs be in sync with YogaNode.java */
      const int MARGIN = 1;
@@ -79,12 +82,19 @@ static void YGTransferLayoutOutputsRecursive(YGNodeRef root) {
      obj->setFieldValue(heightField, YGNodeLayoutGetHeight(root));
      obj->setFieldValue(leftField, YGNodeLayoutGetLeft(root));
      obj->setFieldValue(topField, YGNodeLayoutGetTop(root));
+      obj->setFieldValue<jboolean>(
+          doesLegacyStretchBehaviour,
+          YGNodeLayoutGetDidLegacyStretchFlagAffectLayout(root));

      if ((hasEdgeSetFlag & MARGIN) == MARGIN) {
-        obj->setFieldValue(marginLeftField, YGNodeLayoutGetMargin(root, YGEdgeLeft));
-        obj->setFieldValue(marginTopField, YGNodeLayoutGetMargin(root, YGEdgeTop));
-        obj->setFieldValue(marginRightField, YGNodeLayoutGetMargin(root, YGEdgeRight));
-        obj->setFieldValue(marginBottomField, YGNodeLayoutGetMargin(root, YGEdgeBottom));
+        obj->setFieldValue(
+            marginLeftField, YGNodeLayoutGetMargin(root, YGEdgeLeft));
+        obj->setFieldValue(
+            marginTopField, YGNodeLayoutGetMargin(root, YGEdgeTop));
+        obj->setFieldValue(
+            marginRightField, YGNodeLayoutGetMargin(root, YGEdgeRight));
+        obj->setFieldValue(
+            marginBottomField, YGNodeLayoutGetMargin(root, YGEdgeBottom));
      }

      if ((hasEdgeSetFlag & PADDING) == PADDING) {
@@ -132,31 +142,49 @@ static float YGJNIBaselineFunc(YGNodeRef node, float width, float height) {
  }
 }

-static void YGJNIOnNodeClonedFunc(
+static inline YGNodeRef _jlong2YGNodeRef(jlong addr) {
+  return reinterpret_cast<YGNodeRef>(static_cast<intptr_t>(addr));
+}
+
+static inline YGConfigRef _jlong2YGConfigRef(jlong addr) {
+  return reinterpret_cast<YGConfigRef>(static_cast<intptr_t>(addr));
+}
+
+static YGNodeRef YGJNIOnNodeClonedFunc(
    YGNodeRef oldNode,
-    YGNodeRef newNode,
-    YGNodeRef parent,
+    YGNodeRef owner,
    int childIndex) {
  auto config = oldNode->getConfig();
  if (!config) {
-    return;
+    return nullptr;
  }
+
  static auto onNodeClonedFunc = findClassStatic("com/facebook/yoga/YogaConfig")
-                                     ->getMethod<void(
+                                     ->getMethod<alias_ref<JYogaNode>(
                                         local_ref<JYogaNode>,
                                         local_ref<JYogaNode>,
-                                         local_ref<JYogaNode>,
-                                         jint)>("onNodeCloned");
+                                         jint)>("cloneNode");

  auto context = reinterpret_cast<YGConfigContext*>(YGConfigGetContext(config));
  auto javaConfig = context->config;

-  onNodeClonedFunc(
+  auto newNode = onNodeClonedFunc(
      javaConfig->get(),
      YGNodeJobject(oldNode)->lockLocal(),
-      YGNodeJobject(newNode)->lockLocal(),
-      YGNodeJobject(parent)->lockLocal(),
+      YGNodeJobject(owner)->lockLocal(),
      childIndex);
+
+  static auto replaceChild = findClassStatic("com/facebook/yoga/YogaNode")
+                                     ->getMethod<jlong(
+                                         local_ref<JYogaNode>,
+                                         jint)>("replaceChild");
+
+  jlong newNodeNativePointer = replaceChild(
+      YGNodeJobject(owner)->lockLocal(),
+      newNode,
+      childIndex);
+
+  return _jlong2YGNodeRef(newNodeNativePointer);
 }

 static YGSize YGJNIMeasureFunc(
@@ -224,14 +252,6 @@ static int YGJNILogFunc(const YGConfigRef config,
  return result;
 }

-static inline YGNodeRef _jlong2YGNodeRef(jlong addr) {
-  return reinterpret_cast<YGNodeRef>(static_cast<intptr_t>(addr));
-}
-
-static inline YGConfigRef _jlong2YGConfigRef(jlong addr) {
-  return reinterpret_cast<YGConfigRef>(static_cast<intptr_t>(addr));
-}
-
 jlong jni_YGNodeNew(alias_ref<jobject> thiz) {
  const YGNodeRef node = YGNodeNew();
  node->setContext(new weak_ref<jobject>(make_weak(thiz)));
@@ -264,6 +284,11 @@ void jni_YGNodeFree(alias_ref<jobject> thiz, jlong nativePointer) {
  YGNodeFree(node);
 }

+void jni_YGNodeClearChildren(alias_ref<jobject> thiz, jlong nativePointer) {
+  const YGNodeRef node = _jlong2YGNodeRef(nativePointer);
+  node->clearChildren();
+}
+
 void jni_YGNodeReset(alias_ref<jobject> thiz, jlong nativePointer) {
  const YGNodeRef node = _jlong2YGNodeRef(nativePointer);
  void* context = node->getContext();
@@ -283,6 +308,15 @@ void jni_YGNodeInsertChild(alias_ref<jobject>, jlong nativePointer, jlong childP
  YGNodeInsertChild(_jlong2YGNodeRef(nativePointer), _jlong2YGNodeRef(childPointer), index);
 }

+void jni_YGNodeInsertSharedChild(
+    alias_ref<jobject>,
+    jlong nativePointer,
+    jlong childPointer,
+    jint index) {
+  YGNodeInsertSharedChild(
+      _jlong2YGNodeRef(nativePointer), _jlong2YGNodeRef(childPointer), index);
+}
+
 void jni_YGNodeRemoveChild(alias_ref<jobject>, jlong nativePointer, jlong childPointer) {
  YGNodeRemoveChild(_jlong2YGNodeRef(nativePointer), _jlong2YGNodeRef(childPointer));
 }
@@ -467,6 +501,14 @@ void jni_YGConfigSetExperimentalFeatureEnabled(alias_ref<jobject>,
                                        enabled);
 }

+void jni_YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
+    alias_ref<jobject>,
+    jlong nativePointer,
+    jboolean enabled) {
+  const YGConfigRef config = _jlong2YGConfigRef(nativePointer);
+  YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(config, enabled);
+}
+
 void jni_YGConfigSetUseWebDefaults(alias_ref<jobject>,
                                   jlong nativePointer,
                                   jboolean useWebDefaults) {
@@ -488,10 +530,10 @@ void jni_YGConfigSetUseLegacyStretchBehaviour(alias_ref<jobject>,
  YGConfigSetUseLegacyStretchBehaviour(config, useLegacyStretchBehaviour);
 }

-void jni_YGConfigSetHasNodeClonedFunc(
+void jni_YGConfigSetHasCloneNodeFunc(
    alias_ref<jobject> thiz,
    jlong nativePointer,
-    jboolean hasNodeClonedFunc) {
+    jboolean hasCloneNodeFunc) {
  const YGConfigRef config = _jlong2YGConfigRef(nativePointer);
  auto context = reinterpret_cast<YGConfigContext*>(YGConfigGetContext(config));
  if (context && context->config) {
@@ -499,15 +541,15 @@ void jni_YGConfigSetHasNodeClonedFunc(
    context->config = nullptr;
  }

-  if (hasNodeClonedFunc) {
+  if (hasCloneNodeFunc) {
    if (!context) {
      context = new YGConfigContext();
      YGConfigSetContext(config, context);
    }
    context->config = new global_ref<jobject>(make_global(thiz));
-    YGConfigSetNodeClonedFunc(config, YGJNIOnNodeClonedFunc);
+    YGConfigSetCloneNodeFunc(config, YGJNIOnNodeClonedFunc);
  } else {
-    YGConfigSetNodeClonedFunc(config, nullptr);
+    YGConfigSetCloneNodeFunc(config, nullptr);
  }
 }

@@ -549,7 +591,9 @@ jint JNI_OnLoad(JavaVM *vm, void *) {
            YGMakeNativeMethod(jni_YGNodeNewWithConfig),
            YGMakeNativeMethod(jni_YGNodeFree),
            YGMakeNativeMethod(jni_YGNodeReset),
+            YGMakeNativeMethod(jni_YGNodeClearChildren),
            YGMakeNativeMethod(jni_YGNodeInsertChild),
+            YGMakeNativeMethod(jni_YGNodeInsertSharedChild),
            YGMakeNativeMethod(jni_YGNodeRemoveChild),
            YGMakeNativeMethod(jni_YGNodeCalculateLayout),
            YGMakeNativeMethod(jni_YGNodeMarkDirty),
@@ -624,16 +668,19 @@ jint JNI_OnLoad(JavaVM *vm, void *) {
            YGMakeNativeMethod(jni_YGNodePrint),
            YGMakeNativeMethod(jni_YGNodeClone),
        });
-    registerNatives("com/facebook/yoga/YogaConfig",
-                    {
-                        YGMakeNativeMethod(jni_YGConfigNew),
-                        YGMakeNativeMethod(jni_YGConfigFree),
-                        YGMakeNativeMethod(jni_YGConfigSetExperimentalFeatureEnabled),
-                        YGMakeNativeMethod(jni_YGConfigSetUseWebDefaults),
-                        YGMakeNativeMethod(jni_YGConfigSetPointScaleFactor),
-                        YGMakeNativeMethod(jni_YGConfigSetUseLegacyStretchBehaviour),
-                        YGMakeNativeMethod(jni_YGConfigSetLogger),
-                        YGMakeNativeMethod(jni_YGConfigSetHasNodeClonedFunc),
-                    });
+    registerNatives(
+        "com/facebook/yoga/YogaConfig",
+        {
+            YGMakeNativeMethod(jni_YGConfigNew),
+            YGMakeNativeMethod(jni_YGConfigFree),
+            YGMakeNativeMethod(jni_YGConfigSetExperimentalFeatureEnabled),
+            YGMakeNativeMethod(jni_YGConfigSetUseWebDefaults),
+            YGMakeNativeMethod(jni_YGConfigSetPointScaleFactor),
+            YGMakeNativeMethod(jni_YGConfigSetUseLegacyStretchBehaviour),
+            YGMakeNativeMethod(jni_YGConfigSetLogger),
+            YGMakeNativeMethod(jni_YGConfigSetHasCloneNodeFunc),
+            YGMakeNativeMethod(
+                jni_YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour),
+        });
  });
 }
--- a/java/tests/com/facebook/yoga/YogaNodeTest.java
+++ b/java/tests/com/facebook/yoga/YogaNodeTest.java
@@ -8,7 +8,9 @@
 package com.facebook.yoga;

 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;

@@ -109,21 +111,23 @@ public class YogaNodeTest {
  }

  @Test
-  public void testMeasureFloatMax() {
+  public void testMeasureFloatBigNumber() {
    final YogaNode node = new YogaNode();
-    node.setMeasureFunction(new YogaMeasureFunction() {
-        public long measure(
-            YogaNode node,
-            float width,
-            YogaMeasureMode widthMode,
-            float height,
-            YogaMeasureMode heightMode) {
-          return YogaMeasureOutput.make(Float.MAX_VALUE, Float.MAX_VALUE);
-        }
-    });
+    final float bigNumber = (float) 10E5;
+    node.setMeasureFunction(
+        new YogaMeasureFunction() {
+          public long measure(
+              YogaNode node,
+              float width,
+              YogaMeasureMode widthMode,
+              float height,
+              YogaMeasureMode heightMode) {
+            return YogaMeasureOutput.make(bigNumber, bigNumber);
+          }
+        });
    node.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
-    assertEquals(Float.MAX_VALUE, node.getLayoutWidth(), 0.01f);
-    assertEquals(Float.MAX_VALUE, node.getLayoutHeight(), 0.01f);
+    assertEquals(bigNumber, node.getLayoutWidth(), 0.01f);
+    assertEquals(bigNumber, node.getLayoutHeight(), 0.01f);
  }

  @Test
@@ -248,16 +252,58 @@ public class YogaNodeTest {
    assertEquals(1, clonedChild.getChildCount());
  }

+  @Test
+  public void testCloneWithNewChildren() throws Exception {
+    YogaConfig config = new YogaConfig();
+    YogaNode root = new YogaNode(config);
+    YogaNode child = new YogaNode(config);
+    YogaNode grandChild = new YogaNode(config);
+    root.addChildAt(child, 0);
+    child.addChildAt(grandChild, 0);
+    child.setFlexDirection(YogaFlexDirection.ROW);
+
+    YogaNode clonedChild = child.cloneWithNewChildren();
+
+    assertNotSame(clonedChild, child);
+    assertEquals(YogaFlexDirection.ROW, clonedChild.getFlexDirection());
+    assertEquals(child.getFlexDirection(), clonedChild.getFlexDirection());
+    assertEquals(0, clonedChild.getChildCount());
+    assertEquals(1, child.getChildCount());
+  }
+
+  @Test
+  public void testAddSharedChildCloneWithNewChildren() throws Exception {
+    YogaConfig config = new YogaConfig();
+    YogaNode root = new YogaNode(config);
+    YogaNode child = new YogaNode(config);
+    YogaNode grandChild = new YogaNode(config);
+    root.addChildAt(child, 0);
+    child.addChildAt(grandChild, 0);
+    child.setFlexDirection(YogaFlexDirection.ROW);
+
+    YogaNode clonedChild = child.cloneWithNewChildren();
+
+    assertNotSame(clonedChild, child);
+    assertEquals(YogaFlexDirection.ROW, clonedChild.getFlexDirection());
+    assertEquals(child.getFlexDirection(), clonedChild.getFlexDirection());
+    assertEquals(0, clonedChild.getChildCount());
+    assertEquals(1, child.getChildCount());
+
+    clonedChild.addSharedChildAt(grandChild, 0);
+    assertEquals(1, clonedChild.getChildCount());
+    assertNull(grandChild.getOwner());
+  }
+
  @Test
  public void testCloneNodeListener() throws Exception {
    final AtomicBoolean onNodeClonedExecuted = new AtomicBoolean(false);
    YogaConfig config = new YogaConfig();
-    config.setOnNodeCloned(
-        new YogaNodeClonedFunction() {
+    config.setOnCloneNode(
+        new YogaNodeCloneFunction() {
          @Override
-          public void onNodeCloned(
-              YogaNode oldNode, YogaNode newNode, YogaNode parent, int childIndex) {
+          public YogaNode cloneNode(YogaNode oldNode, YogaNode owner, int childIndex) {
            onNodeClonedExecuted.set(true);
+            return oldNode.clone();
          }
        });
    YogaNode root = new YogaNode(config);
@@ -265,6 +311,7 @@ public class YogaNodeTest {
    root.setHeight(100f);
    YogaNode child0 = new YogaNode(config);
    root.addChildAt(child0, 0);
+    child0.setWidth(50f);
    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);

    // Force a clone to happen.
@@ -273,20 +320,24 @@ public class YogaNodeTest {
    root2.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);

    assertTrue(onNodeClonedExecuted.get());
+    assertEquals(1, root2.getChildCount());
+    YogaNode clonedNode = root2.getChildAt(0);
+    assertNotSame(child0, clonedNode);
+    assertEquals(child0.getWidth(), clonedNode.getWidth());
+    assertEquals(50f, clonedNode.getWidth().value, 0.01f);
  }

  @Test
  public void testOnNodeClonedLeak() throws Exception {
    YogaConfig config = new YogaConfig();
-    config.setOnNodeCloned(
-        new YogaNodeClonedFunction() {
+    config.setOnCloneNode(
+        new YogaNodeCloneFunction() {
          @Override
-          public void onNodeCloned(
-              YogaNode oldNode, YogaNode newNode, YogaNode parent, int childIndex) {
-            // Do nothing
+          public YogaNode cloneNode(YogaNode oldNode, YogaNode owner, int childIndex) {
+            return oldNode.clone();
          }
        });
-    config.setOnNodeCloned(null);
+    config.setOnCloneNode(null);
    WeakReference<Object> ref = new WeakReference<Object>(config);
    // noinspection UnusedAssignment
    config = null;
@@ -302,4 +353,27 @@ public class YogaNodeTest {
    }
    fail("YogaConfig leaked");
  }
+
+  @Test
+  public void testFlagShouldDiffLayoutWithoutLegacyStretchBehaviour() throws Exception {
+    YogaConfig config = new YogaConfig();
+    config.setShouldDiffLayoutWithoutLegacyStretchBehaviour(true);
+    config.setUseLegacyStretchBehaviour(true);
+    YogaNode root = new YogaNode(config);
+    root.setWidth(500);
+    root.setHeight(500);
+    YogaNode root_child0 = new YogaNode(config);
+    root_child0.setAlignItems(YogaAlign.FLEX_START);
+    root.addChildAt(root_child0, 0);
+    YogaNode root_child0_child0 = new YogaNode(config);
+    root_child0_child0.setFlexGrow(1);
+    root_child0_child0.setFlexShrink(1);
+    root_child0.addChildAt(root_child0_child0, 0);
+    YogaNode root_child0_child0_child0 = new YogaNode(config);
+    root_child0_child0_child0.setFlexGrow(1);
+    root_child0_child0_child0.setFlexShrink(1);
+    root_child0_child0.addChildAt(root_child0_child0_child0, 0);
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED);
+    assertFalse(root.getDoesLegacyStretchFlagAffectsLayout());
+  }
 }
--- a/tests/YGStyleTest.cpp
+++ b/tests/YGStyleTest.cpp
@@ -57,3 +57,26 @@ TEST(YogaTest, copy_style_modified_same) {
  YGNodeFree(node0);
  YGNodeFree(node1);
 }
+
+TEST(YogaTest, initialise_flexShrink_flexGrow) {
+  const YGNodeRef node0 = YGNodeNew();
+  YGNodeStyleSetFlexShrink(node0, 1);
+  ASSERT_EQ(1, YGNodeStyleGetFlexShrink(node0));
+
+  YGNodeStyleSetFlexShrink(node0, YGUndefined);
+  YGNodeStyleSetFlexGrow(node0, 3);
+  ASSERT_EQ(
+      0,
+      YGNodeStyleGetFlexShrink(
+          node0)); // Default value is Zero, if flex shrink is not defined
+  ASSERT_EQ(3, YGNodeStyleGetFlexGrow(node0));
+
+  YGNodeStyleSetFlexGrow(node0, YGUndefined);
+  YGNodeStyleSetFlexShrink(node0, 3);
+  ASSERT_EQ(
+      0,
+      YGNodeStyleGetFlexGrow(
+          node0)); // Default value is Zero, if flex grow is not defined
+  ASSERT_EQ(3, YGNodeStyleGetFlexShrink(node0));
+  YGNodeFree(node0);
+}
--- a/tests/YGTraversalTest.cpp
+++ b/tests/YGTraversalTest.cpp
@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * 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>
+
+TEST(YogaTest, pre_order_traversal) {
+  YGNodeRef const root = YGNodeNew();
+  YGNodeRef const root_child0 = YGNodeNew();
+  YGNodeRef const root_child1 = YGNodeNew();
+  YGNodeRef const root_child0_child0 = YGNodeNew();
+  
+  YGNodeSetChildren(root, {root_child0, root_child1});
+  YGNodeInsertChild(root_child0, root_child0_child0, 0);
+  
+  std::vector<YGNodeRef> visited;
+  YGTraversePreOrder(root, [&visited](YGNodeRef node) {
+    visited.push_back(node);
+  });
+  
+  const std::vector<YGNodeRef> expected = {
+    root,
+    root_child0,
+    root_child0_child0,
+    root_child1
+  };
+  ASSERT_EQ(visited, expected);
+
+  YGNodeFreeRecursive(root);
+}
--- a/tests/YGTreeMutationTest.cpp
+++ b/tests/YGTreeMutationTest.cpp
@@ -0,0 +1,111 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * 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>
+
+static std::vector<YGNodeRef> getChildren(YGNodeRef const node)
+{
+  const uint32_t count = YGNodeGetChildCount(node);
+  std::vector<YGNodeRef> children;
+  children.reserve(count);
+  for (uint32_t i = 0 ; i < count ; i++) {
+    children.push_back(YGNodeGetChild(node, i));
+  }
+  return children;
+}
+
+TEST(YogaTest, set_children_adds_children_to_parent) {
+  YGNodeRef const root = YGNodeNew();
+  YGNodeRef const root_child0 = YGNodeNew();
+  YGNodeRef const root_child1 = YGNodeNew();
+
+  YGNodeSetChildren(root, {root_child0, root_child1});
+
+  const std::vector<YGNodeRef> children = getChildren(root);
+  const std::vector<YGNodeRef> expectedChildren = {root_child0, root_child1};
+  ASSERT_EQ(children, expectedChildren);
+
+  const std::vector<YGNodeRef> owners = {YGNodeGetOwner(root_child0), YGNodeGetOwner(root_child1)};
+  const std::vector<YGNodeRef> expectedOwners = {root, root};
+  ASSERT_EQ(owners, expectedOwners);
+
+  YGNodeFreeRecursive(root);
+}
+
+TEST(YogaTest, set_children_to_empty_removes_old_children) {
+  YGNodeRef const root = YGNodeNew();
+  YGNodeRef const root_child0 = YGNodeNew();
+  YGNodeRef const root_child1 = YGNodeNew();
+
+  YGNodeSetChildren(root, {root_child0, root_child1});
+  YGNodeSetChildren(root, {});
+
+  const std::vector<YGNodeRef> children = getChildren(root);
+  const std::vector<YGNodeRef> expectedChildren = {};
+  ASSERT_EQ(children, expectedChildren);
+
+  const std::vector<YGNodeRef> owners = {YGNodeGetOwner(root_child0), YGNodeGetOwner(root_child1)};
+  const std::vector<YGNodeRef> expectedOwners = {nullptr, nullptr};
+  ASSERT_EQ(owners, expectedOwners);
+
+  YGNodeFreeRecursive(root);
+}
+
+TEST(YogaTest, set_children_replaces_non_common_children) {
+  YGNodeRef const root = YGNodeNew();
+  YGNodeRef const root_child0 = YGNodeNew();
+  YGNodeRef const root_child1 = YGNodeNew();
+
+  YGNodeSetChildren(root, {root_child0, root_child1});
+
+  YGNodeRef const root_child2 = YGNodeNew();
+  YGNodeRef const root_child3 = YGNodeNew();
+
+  YGNodeSetChildren(root, {root_child2, root_child3});
+
+  const std::vector<YGNodeRef> children = getChildren(root);
+  const std::vector<YGNodeRef> expectedChildren = {root_child2, root_child3};
+  ASSERT_EQ(children, expectedChildren);
+
+  const std::vector<YGNodeRef> owners = {YGNodeGetOwner(root_child0), YGNodeGetOwner(root_child1)};
+  const std::vector<YGNodeRef> expectedOwners = {nullptr, nullptr};
+  ASSERT_EQ(owners, expectedOwners);
+
+  YGNodeFreeRecursive(root);
+  YGNodeFree(root_child0);
+  YGNodeFree(root_child1);
+}
+
+TEST(YogaTest, set_children_keeps_and_reorders_common_children) {
+  YGNodeRef const root = YGNodeNew();
+  YGNodeRef const root_child0 = YGNodeNew();
+  YGNodeRef const root_child1 = YGNodeNew();
+  YGNodeRef const root_child2 = YGNodeNew();
+
+  YGNodeSetChildren(root, {root_child0, root_child1, root_child2});
+
+  YGNodeRef const root_child3 = YGNodeNew();
+
+  YGNodeSetChildren(root, {root_child2, root_child1, root_child3});
+
+  const std::vector<YGNodeRef> children = getChildren(root);
+  const std::vector<YGNodeRef> expectedChildren = {root_child2, root_child1, root_child3};
+  ASSERT_EQ(children, expectedChildren);
+
+  const std::vector<YGNodeRef> owners = {
+    YGNodeGetOwner(root_child0),
+    YGNodeGetOwner(root_child1),
+    YGNodeGetOwner(root_child2),
+    YGNodeGetOwner(root_child3)
+  };
+  const std::vector<YGNodeRef> expectedOwners = {nullptr, root, root, root};
+  ASSERT_EQ(owners, expectedOwners);
+
+  YGNodeFreeRecursive(root);
+  YGNodeFree(root_child0);
+}
--- a/website/contents/getting-started/standalone.md
+++ b/website/contents/getting-started/standalone.md
@@ -18,10 +18,45 @@ dependencies {

 ### Javascript

+The JavaScript bindings for Yoga can be used from node.js and within the browser.
+When using Yoga from node.js the native library is used, in browesers a pure JS
+version is used (corss-compiled using [emscripten](http://kripken.github.io/emscripten-site/)).
+
 ```
 $> yarn add yoga-layout
 ```

+This is an example on how to use Yoga in JavaScript, for a full API reference,
+have a look at the [flow-type definitions](https://github.com/facebook/yoga/blob/master/javascript/sources/entry-common.js#L123).
+
+```js
+import yoga, {Node} from 'yoga-layout';
+
+const root = Node.create();
+root.setWidth(500);
+root.setHeight(300);
+root.setJustifyContent(yoga.JUSTIFY_CENTER);
+
+const node1 = Node.create();
+node1.setWidth(100);
+node1.setHeight(100);
+
+const node2 = Node.create();
+node2.setWidth(100);
+node2.setHeight(100);
+
+root.insertChild(node1, 0);
+root.insertChild(node2, 1);
+
+root.calculateLayout(500, 300, yoga.DIRECTION_LTR);
+console.log(root.getComputedLayout());
+// {left: 0, top: 0, width: 500, height: 300}
+console.log(node1.getComputedLayout());
+// {left: 150, top: 0, width: 100, height: 100}
+console.log(node2.getComputedLayout());
+// {left: 250, top: 0, width: 100, height: 100}
+```
+
 ### iOS

 ```
--- a/yoga/Utils.cpp
+++ b/yoga/Utils.cpp
@@ -49,3 +49,20 @@ bool YGFloatsEqual(const float a, const float b) {
  }
  return YGFloatIsUndefined(a) && YGFloatIsUndefined(b);
 }
+
+float YGFloatSanitize(const float& val) {
+  return YGFloatIsUndefined(val) ? 0 : val;
+}
+
+float YGUnwrapFloatOptional(const YGFloatOptional& op) {
+  return op.isUndefined() ? YGUndefined : op.getValue();
+}
+
+YGFloatOptional YGFloatOptionalMax(
+    const YGFloatOptional& op1,
+    const YGFloatOptional& op2) {
+  if (!op1.isUndefined() && !op2.isUndefined()) {
+    return op1.getValue() > op2.getValue() ? op1 : op2;
+  }
+  return op1.isUndefined() ? op2 : op1;
+}
--- a/yoga/Utils.h
+++ b/yoga/Utils.h
@@ -40,12 +40,12 @@ struct YGCollectFlexItemsRowValues {
  float sizeConsumedOnCurrentLine;
  float totalFlexGrowFactors;
  float totalFlexShrinkScaledFactors;
-  float endOfLineIndex;
+  uint32_t endOfLineIndex;
  std::vector<YGNodeRef> relativeChildren;
  float remainingFreeSpace;
  // The size of the mainDim for the row after considering size, padding, margin
  // and border of flex items. This is used to calculate maxLineDim after going
-  // through all the rows to decide on the main axis size of parent.
+  // through all the rows to decide on the main axis size of owner.
  float mainDim;
  // The size of the crossDim for the row after considering size, padding,
  // margin and border of flex items. Used for calculating containers crossSize.
@@ -65,6 +65,10 @@ bool YGFloatsEqual(const float a, const float b);
 // compiler flag.
 float YGFloatMax(const float a, const float b);

+YGFloatOptional YGFloatOptionalMax(
+    const YGFloatOptional& op1,
+    const YGFloatOptional& op2);
+
 // We need custom min function, since we want that, if one argument is
 // YGUndefined then the min funtion should return the other argument as the min
 // value. We wouldn't have needed a custom min function if YGUndefined was NAN
@@ -86,6 +90,14 @@ bool YGFloatArrayEqual(
  return areEqual;
 }

+// This function returns 0 if YGFloatIsUndefined(val) is true and val otherwise
+float YGFloatSanitize(const float& val);
+
+// This function unwraps optional and returns YGUndefined if not defined or
+// op.value otherwise
+// TODO: Get rid off this function
+float YGUnwrapFloatOptional(const YGFloatOptional& op);
+
 YGFlexDirection YGFlexDirectionCross(
    const YGFlexDirection flexDirection,
    const YGDirection direction);
@@ -95,17 +107,18 @@ inline bool YGFlexDirectionIsRow(const YGFlexDirection flexDirection) {
      flexDirection == YGFlexDirectionRowReverse;
 }

-inline float YGResolveValue(const YGValue value, const float parentSize) {
+inline YGFloatOptional YGResolveValue(const YGValue value, const float ownerSize) {
  switch (value.unit) {
    case YGUnitUndefined:
    case YGUnitAuto:
-      return YGUndefined;
+      return YGFloatOptional();
    case YGUnitPoint:
-      return value.value;
+      return YGFloatOptional(value.value);
    case YGUnitPercent:
-      return value.value * parentSize * 0.01;
+      return YGFloatOptional(
+          static_cast<float>(value.value * ownerSize * 0.01));
  }
-  return YGUndefined;
+  return YGFloatOptional();
 }

 inline bool YGFlexDirectionIsColumn(const YGFlexDirection flexDirection) {
@@ -127,8 +140,9 @@ inline YGFlexDirection YGResolveFlexDirection(
  return flexDirection;
 }

-static inline float YGResolveValueMargin(
+static inline YGFloatOptional YGResolveValueMargin(
    const YGValue value,
-    const float parentSize) {
-  return value.unit == YGUnitAuto ? 0 : YGResolveValue(value, parentSize);
+    const float ownerSize) {
+  return value.unit == YGUnitAuto ? YGFloatOptional(0)
+                                  : YGResolveValue(value, ownerSize);
 }
--- a/yoga/YGConfig.cpp
+++ b/yoga/YGConfig.cpp
@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "YGConfig.h"
+
+const std::array<bool, YGExperimentalFeatureCount>
+    kYGDefaultExperimentalFeatures = {{false}};
+
+YGConfig::YGConfig(YGLogger logger)
+    : experimentalFeatures(kYGDefaultExperimentalFeatures),
+      useWebDefaults(false),
+      useLegacyStretchBehaviour(false),
+      shouldDiffLayoutWithoutLegacyStretchBehaviour(false),
+      pointScaleFactor(1.0f), logger(logger), cloneNodeCallback(nullptr),
+      context(nullptr) {}
--- a/yoga/YGConfig.h
+++ b/yoga/YGConfig.h
@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * 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-internal.h"
+#include "Yoga.h"
+
+struct YGConfig {
+  std::array<bool, YGExperimentalFeatureCount> experimentalFeatures;
+  bool useWebDefaults;
+  bool useLegacyStretchBehaviour;
+  bool shouldDiffLayoutWithoutLegacyStretchBehaviour;
+  float pointScaleFactor;
+  YGLogger logger;
+  YGCloneNodeFunc cloneNodeCallback;
+  void* context;
+
+  YGConfig(YGLogger logger);
+};
--- a/yoga/YGFloatOptional.cpp
+++ b/yoga/YGFloatOptional.cpp
@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "YGFloatOptional.h"
+#include <cstdlib>
+#include <iostream>
+#include "Yoga.h"
+
+YGFloatOptional::YGFloatOptional(const float& value) {
+  if (YGFloatIsUndefined(value)) {
+    isUndefined_ = true;
+    value_ = 0;
+  } else {
+    value_ = value;
+    isUndefined_ = false;
+  }
+}
+
+YGFloatOptional::YGFloatOptional() : value_(0), isUndefined_(true) {}
+
+const float& YGFloatOptional::getValue() const {
+  if (isUndefined_) {
+    // Abort, accessing a value of an undefined float optional
+    std::cerr << "Tried to get value of an undefined YGFloatOptional\n";
+    std::exit(EXIT_FAILURE);
+  }
+  return value_;
+}
+
+void YGFloatOptional::setValue(const float& val) {
+  value_ = val;
+  isUndefined_ = false;
+}
+
+const bool& YGFloatOptional::isUndefined() const {
+  return isUndefined_;
+}
+
+bool YGFloatOptional::operator==(const YGFloatOptional& op) const {
+  if (isUndefined_ == op.isUndefined()) {
+    return isUndefined_ ? true : value_ == op.getValue();
+  }
+  return false;
+}
+
+bool YGFloatOptional::operator!=(const YGFloatOptional& op) const {
+  return !(*this == op);
+}
+
+bool YGFloatOptional::operator==(const float& val) const {
+  if (YGFloatIsUndefined(val) == isUndefined_) {
+    return isUndefined_ ? true : val == value_;
+  }
+  return false;
+}
+
+bool YGFloatOptional::operator!=(const float& val) const {
+  return !(*this == val);
+}
+
+YGFloatOptional YGFloatOptional::operator+(const YGFloatOptional& op) {
+  if (!isUndefined_ && !op.isUndefined_) {
+    return YGFloatOptional(value_ + op.value_);
+  }
+  return YGFloatOptional();
+}
+
+bool YGFloatOptional::operator>(const YGFloatOptional& op) const {
+  if (isUndefined_ || op.isUndefined_) {
+    return false;
+  }
+  return value_ > op.value_;
+}
+
+bool YGFloatOptional::operator<(const YGFloatOptional& op) const {
+  if (isUndefined_ || op.isUndefined_) {
+    return false;
+  }
+  return value_ < op.value_;
+}
+
+bool YGFloatOptional::operator>=(const YGFloatOptional& op) const {
+  return *this == op ? true : *this > op;
+}
+
+bool YGFloatOptional::operator<=(const YGFloatOptional& op) const {
+  return *this == op ? true : *this < op;
+}
--- a/yoga/YGFloatOptional.h
+++ b/yoga/YGFloatOptional.h
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+struct YGFloatOptional {
+ private:
+  float value_;
+  bool isUndefined_;
+
+ public:
+  explicit YGFloatOptional(const float& value);
+  explicit YGFloatOptional();
+
+  // Program will terminate if the value of an undefined is accessed. Please
+  // make sure to check if the optional is defined before calling this function.
+  // To check if float optional is defined, use `isUndefined()`.
+  const float& getValue() const;
+
+  // Sets the value of float optional, and thus isUndefined is assigned false.
+  void setValue(const float& val);
+
+  const bool& isUndefined() const;
+
+  YGFloatOptional operator+(const YGFloatOptional& op);
+  bool operator>(const YGFloatOptional& op) const;
+  bool operator<(const YGFloatOptional& op) const;
+  bool operator>=(const YGFloatOptional& op) const;
+  bool operator<=(const YGFloatOptional& op) const;
+  bool operator==(const YGFloatOptional& op) const;
+  bool operator!=(const YGFloatOptional& op) const;
+
+  bool operator==(const float& val) const;
+  bool operator!=(const float& val) const;
+};
--- a/yoga/YGLayout.cpp
+++ b/yoga/YGLayout.cpp
@@ -19,10 +19,10 @@ YGLayout::YGLayout()
      padding(),
      direction(YGDirectionInherit),
      computedFlexBasisGeneration(0),
-      computedFlexBasis(YGUndefined),
+      computedFlexBasis(YGFloatOptional()),
      hadOverflow(false),
      generationCount(0),
-      lastParentDirection((YGDirection)-1),
+      lastOwnerDirection((YGDirection)-1),
      nextCachedMeasurementsIndex(0),
      cachedMeasurements(),
      measuredDimensions(kYGDefaultDimensionValues),
@@ -37,18 +37,15 @@ bool YGLayout::operator==(YGLayout layout) const {
      YGFloatArrayEqual(border, layout.border) &&
      YGFloatArrayEqual(padding, layout.padding) &&
      direction == layout.direction && hadOverflow == layout.hadOverflow &&
-      lastParentDirection == layout.lastParentDirection &&
+      lastOwnerDirection == layout.lastOwnerDirection &&
      nextCachedMeasurementsIndex == layout.nextCachedMeasurementsIndex &&
-      cachedLayout == layout.cachedLayout;
+      cachedLayout == layout.cachedLayout &&
+      computedFlexBasis == layout.computedFlexBasis;

  for (uint32_t i = 0; i < YG_MAX_CACHED_RESULT_COUNT && isEqual; ++i) {
    isEqual = isEqual && cachedMeasurements[i] == layout.cachedMeasurements[i];
  }

-  if (!YGFloatIsUndefined(computedFlexBasis) ||
-      !YGFloatIsUndefined(layout.computedFlexBasis)) {
-    isEqual = isEqual && (computedFlexBasis == layout.computedFlexBasis);
-  }
  if (!YGFloatIsUndefined(measuredDimensions[0]) ||
      !YGFloatIsUndefined(layout.measuredDimensions[0])) {
    isEqual =
--- a/yoga/YGLayout.h
+++ b/yoga/YGLayout.h
@@ -6,6 +6,7 @@
 */

 #pragma once
+#include "YGFloatOptional.h"
 #include "Yoga-internal.h"

 struct YGLayout {
@@ -17,13 +18,13 @@ struct YGLayout {
  YGDirection direction;

  uint32_t computedFlexBasisGeneration;
-  float computedFlexBasis;
+  YGFloatOptional computedFlexBasis;
  bool hadOverflow;

  // Instead of recomputing the entire layout every single time, we
  // cache some information to break early when nothing changed
  uint32_t generationCount;
-  YGDirection lastParentDirection;
+  YGDirection lastOwnerDirection;

  uint32_t nextCachedMeasurementsIndex;
  std::array<YGCachedMeasurement, YG_MAX_CACHED_RESULT_COUNT>
--- a/yoga/YGNode.cpp
+++ b/yoga/YGNode.cpp
@@ -49,8 +49,8 @@ uint32_t YGNode::getLineIndex() const {
  return lineIndex_;
 }

-YGNodeRef YGNode::getParent() const {
-  return parent_;
+YGNodeRef YGNode::getOwner() const {
+  return owner_;
 }

 YGVector YGNode::getChildren() const {
@@ -85,9 +85,9 @@ std::array<YGValue, 2> YGNode::getResolvedDimensions() const {
  return resolvedDimensions_;
 }

-float YGNode::getLeadingPosition(
-    const YGFlexDirection axis,
-    const float axisSize) {
+YGFloatOptional YGNode::getLeadingPosition(
+    const YGFlexDirection& axis,
+    const float& axisSize) const {
  if (YGFlexDirectionIsRow(axis)) {
    const YGValue* leadingPosition =
        YGComputedEdgeValue(style_.position, YGEdgeStart, &YGValueUndefined);
@@ -100,13 +100,13 @@ float YGNode::getLeadingPosition(
      YGComputedEdgeValue(style_.position, leading[axis], &YGValueUndefined);

  return leadingPosition->unit == YGUnitUndefined
-      ? 0.0f
+      ? YGFloatOptional(0)
      : YGResolveValue(*leadingPosition, axisSize);
 }

-float YGNode::getTrailingPosition(
-    const YGFlexDirection axis,
-    const float axisSize) {
+YGFloatOptional YGNode::getTrailingPosition(
+    const YGFlexDirection& axis,
+    const float& axisSize) const {
  if (YGFlexDirectionIsRow(axis)) {
    const YGValue* trailingPosition =
        YGComputedEdgeValue(style_.position, YGEdgeEnd, &YGValueUndefined);
@@ -119,11 +119,11 @@ float YGNode::getTrailingPosition(
      YGComputedEdgeValue(style_.position, trailing[axis], &YGValueUndefined);

  return trailingPosition->unit == YGUnitUndefined
-      ? 0.0f
+      ? YGFloatOptional(0)
      : YGResolveValue(*trailingPosition, axisSize);
 }

-bool YGNode::isLeadingPositionDefined(const YGFlexDirection axis) {
+bool YGNode::isLeadingPositionDefined(const YGFlexDirection& axis) const {
  return (YGFlexDirectionIsRow(axis) &&
          YGComputedEdgeValue(style_.position, YGEdgeStart, &YGValueUndefined)
                  ->unit != YGUnitUndefined) ||
@@ -131,7 +131,7 @@ bool YGNode::isLeadingPositionDefined(const YGFlexDirection axis) {
          ->unit != YGUnitUndefined;
 }

-bool YGNode::isTrailingPosDefined(const YGFlexDirection axis) {
+bool YGNode::isTrailingPosDefined(const YGFlexDirection& axis) const {
  return (YGFlexDirectionIsRow(axis) &&
          YGComputedEdgeValue(style_.position, YGEdgeEnd, &YGValueUndefined)
                  ->unit != YGUnitUndefined) ||
@@ -139,9 +139,9 @@ bool YGNode::isTrailingPosDefined(const YGFlexDirection axis) {
          ->unit != YGUnitUndefined;
 }

-float YGNode::getLeadingMargin(
-    const YGFlexDirection axis,
-    const float widthSize) {
+YGFloatOptional YGNode::getLeadingMargin(
+    const YGFlexDirection& axis,
+    const float& widthSize) const {
  if (YGFlexDirectionIsRow(axis) &&
      style_.margin[YGEdgeStart].unit != YGUnitUndefined) {
    return YGResolveValueMargin(style_.margin[YGEdgeStart], widthSize);
@@ -152,9 +152,9 @@ float YGNode::getLeadingMargin(
      widthSize);
 }

-float YGNode::getTrailingMargin(
-    const YGFlexDirection axis,
-    const float widthSize) {
+YGFloatOptional YGNode::getTrailingMargin(
+    const YGFlexDirection& axis,
+    const float& widthSize) const {
  if (YGFlexDirectionIsRow(axis) &&
      style_.margin[YGEdgeEnd].unit != YGUnitUndefined) {
    return YGResolveValueMargin(style_.margin[YGEdgeEnd], widthSize);
@@ -165,9 +165,9 @@ float YGNode::getTrailingMargin(
      widthSize);
 }

-float YGNode::getMarginForAxis(
-    const YGFlexDirection axis,
-    const float widthSize) {
+YGFloatOptional YGNode::getMarginForAxis(
+    const YGFlexDirection& axis,
+    const float& widthSize) const {
  return getLeadingMargin(axis, widthSize) + getTrailingMargin(axis, widthSize);
 }

@@ -225,11 +225,11 @@ void YGNode::setDirtiedFunc(YGDirtiedFunc dirtiedFunc) {
  dirtied_ = dirtiedFunc;
 }

-void YGNode::setStyle(YGStyle style) {
+void YGNode::setStyle(const YGStyle& style) {
  style_ = style;
 }

-void YGNode::setLayout(YGLayout layout) {
+void YGNode::setLayout(const YGLayout& layout) {
  layout_ = layout;
 }

@@ -237,11 +237,11 @@ void YGNode::setLineIndex(uint32_t lineIndex) {
  lineIndex_ = lineIndex;
 }

-void YGNode::setParent(YGNodeRef parent) {
-  parent_ = parent;
+void YGNode::setOwner(YGNodeRef owner) {
+  owner_ = owner;
 }

-void YGNode::setChildren(YGVector children) {
+void YGNode::setChildren(const YGVector& children) {
  children_ = children;
 }

@@ -305,11 +305,12 @@ void YGNode::setLayoutPadding(float padding, int index) {
  layout_.padding[index] = padding;
 }

-void YGNode::setLayoutLastParentDirection(YGDirection direction) {
-  layout_.lastParentDirection = direction;
+void YGNode::setLayoutLastOwnerDirection(YGDirection direction) {
+  layout_.lastOwnerDirection = direction;
 }

-void YGNode::setLayoutComputedFlexBasis(float computedFlexBasis) {
+void YGNode::setLayoutComputedFlexBasis(
+    const YGFloatOptional& computedFlexBasis) {
  layout_.computedFlexBasis = computedFlexBasis;
 }

@@ -336,41 +337,54 @@ void YGNode::setLayoutDimension(float dimension, int index) {

 // If both left and right are defined, then use left. Otherwise return
 // +left or -right depending on which is defined.
-float YGNode::relativePosition(
-    const YGFlexDirection axis,
-    const float axisSize) {
-  return isLeadingPositionDefined(axis) ? getLeadingPosition(axis, axisSize)
-                                        : -getTrailingPosition(axis, axisSize);
+YGFloatOptional YGNode::relativePosition(
+    const YGFlexDirection& axis,
+    const float& axisSize) const {
+  if (isLeadingPositionDefined(axis)) {
+    return getLeadingPosition(axis, axisSize);
+  }
+
+  YGFloatOptional trailingPosition = getTrailingPosition(axis, axisSize);
+  if (!trailingPosition.isUndefined()) {
+    trailingPosition.setValue(-1 * trailingPosition.getValue());
+  }
+  return trailingPosition;
 }

 void YGNode::setPosition(
    const YGDirection direction,
    const float mainSize,
    const float crossSize,
-    const float parentWidth) {
+    const float ownerWidth) {
  /* Root nodes should be always layouted as LTR, so we don't return negative
   * values. */
  const YGDirection directionRespectingRoot =
-      parent_ != nullptr ? direction : YGDirectionLTR;
+      owner_ != nullptr ? direction : YGDirectionLTR;
  const YGFlexDirection mainAxis =
      YGResolveFlexDirection(style_.flexDirection, directionRespectingRoot);
  const YGFlexDirection crossAxis =
      YGFlexDirectionCross(mainAxis, directionRespectingRoot);

-  const float relativePositionMain = relativePosition(mainAxis, mainSize);
-  const float relativePositionCross = relativePosition(crossAxis, crossSize);
+  const YGFloatOptional relativePositionMain =
+      relativePosition(mainAxis, mainSize);
+  const YGFloatOptional relativePositionCross =
+      relativePosition(crossAxis, crossSize);

  setLayoutPosition(
-      getLeadingMargin(mainAxis, parentWidth) + relativePositionMain,
+      YGUnwrapFloatOptional(
+          getLeadingMargin(mainAxis, ownerWidth) + relativePositionMain),
      leading[mainAxis]);
  setLayoutPosition(
-      getTrailingMargin(mainAxis, parentWidth) + relativePositionMain,
+      YGUnwrapFloatOptional(
+          getTrailingMargin(mainAxis, ownerWidth) + relativePositionMain),
      trailing[mainAxis]);
  setLayoutPosition(
-      getLeadingMargin(crossAxis, parentWidth) + relativePositionCross,
+      YGUnwrapFloatOptional(
+          getLeadingMargin(crossAxis, ownerWidth) + relativePositionCross),
      leading[crossAxis]);
  setLayoutPosition(
-      getTrailingMargin(crossAxis, parentWidth) + relativePositionCross,
+      YGUnwrapFloatOptional(
+          getTrailingMargin(crossAxis, ownerWidth) + relativePositionCross),
      trailing[crossAxis]);
 }

@@ -385,7 +399,7 @@ YGNode::YGNode()
      style_(YGStyle()),
      layout_(YGLayout()),
      lineIndex_(0),
-      parent_(nullptr),
+      owner_(nullptr),
      children_(YGVector()),
      nextChild_(nullptr),
      config_(nullptr),
@@ -403,7 +417,7 @@ YGNode::YGNode(const YGNode& node)
      style_(node.style_),
      layout_(node.layout_),
      lineIndex_(node.lineIndex_),
-      parent_(node.parent_),
+      owner_(node.owner_),
      children_(node.children_),
      nextChild_(node.nextChild_),
      config_(node.config_),
@@ -423,10 +437,10 @@ YGNode::YGNode(
    YGBaselineFunc baseline,
    YGDirtiedFunc dirtied,
    YGStyle style,
-    YGLayout layout,
+    const YGLayout& layout,
    uint32_t lineIndex,
-    YGNodeRef parent,
-    YGVector children,
+    YGNodeRef owner,
+    const YGVector& children,
    YGNodeRef nextChild,
    YGConfigRef config,
    bool isDirty,
@@ -441,7 +455,7 @@ YGNode::YGNode(
      style_(style),
      layout_(layout),
      lineIndex_(lineIndex),
-      parent_(parent),
+      owner_(owner),
      children_(children),
      nextChild_(nextChild),
      config_(config),
@@ -467,7 +481,7 @@ YGNode& YGNode::operator=(const YGNode& node) {
  style_ = node.style_;
  layout_ = node.layout_;
  lineIndex_ = node.getLineIndex();
-  parent_ = node.getParent();
+  owner_ = node.getOwner();
  children_ = node.getChildren();
  nextChild_ = node.getNextChild();
  config_ = node.getConfig();
@@ -500,7 +514,7 @@ YGValue YGNode::resolveFlexBasisPtr() const {
  if (flexBasis.unit != YGUnitAuto && flexBasis.unit != YGUnitUndefined) {
    return flexBasis;
  }
-  if (!YGFloatIsUndefined(style_.flex) && style_.flex > 0.0f) {
+  if (!style_.flex.isUndefined() && style_.flex.getValue() > 0.0f) {
    return config_->useWebDefaults ? YGValueAuto : YGValueZero;
  }
  return YGValueAuto;
@@ -518,9 +532,9 @@ void YGNode::resolveDimension() {
  }
 }

-YGDirection YGNode::resolveDirection(const YGDirection parentDirection) {
+YGDirection YGNode::resolveDirection(const YGDirection ownerDirection) {
  if (style_.direction == YGDirectionInherit) {
-    return parentDirection > YGDirectionInherit ? parentDirection
+    return ownerDirection > YGDirectionInherit ? ownerDirection
                                                : YGDirectionLTR;
  } else {
    return style_.direction;
@@ -550,32 +564,35 @@ void YGNode::cloneChildrenIfNeeded() {
  }

  const YGNodeRef firstChild = children_.front();
-  if (firstChild->getParent() == this) {
-    // If the first child has this node as its parent, we assume that it is
+  if (firstChild->getOwner() == this) {
+    // If the first child has this node as its owner, we assume that it is
    // already unique. We can do this because if we have it has a child, that
-    // means that its parent was at some point cloned which made that subtree
+    // means that its owner was at some point cloned which made that subtree
    // immutable. We also assume that all its sibling are cloned as well.
    return;
  }

-  const YGNodeClonedFunc cloneNodeCallback = config_->cloneNodeCallback;
+  const YGCloneNodeFunc cloneNodeCallback = config_->cloneNodeCallback;
  for (uint32_t i = 0; i < childCount; ++i) {
    const YGNodeRef oldChild = children_[i];
-    const YGNodeRef newChild = YGNodeClone(oldChild);
-    replaceChild(newChild, i);
-    newChild->setParent(this);
+    YGNodeRef newChild = nullptr;
    if (cloneNodeCallback) {
-      cloneNodeCallback(oldChild, newChild, this, i);
+      newChild = cloneNodeCallback(oldChild, this, i);
    }
+    if (newChild == nullptr) {
+      newChild = YGNodeClone(oldChild);
+    }
+    replaceChild(newChild, i);
+    newChild->setOwner(this);
  }
 }

 void YGNode::markDirtyAndPropogate() {
  if (!isDirty_) {
    setDirty(true);
-    setLayoutComputedFlexBasis(YGUndefined);
-    if (parent_) {
-      parent_->markDirtyAndPropogate();
+    setLayoutComputedFlexBasis(YGFloatOptional());
+    if (owner_) {
+      owner_->markDirtyAndPropogate();
    }
  }
 }
@@ -589,28 +606,28 @@ void YGNode::markDirtyAndPropogateDownwards() {

 float YGNode::resolveFlexGrow() {
  // Root nodes flexGrow should always be 0
-  if (parent_ == nullptr) {
+  if (owner_ == nullptr) {
    return 0.0;
  }
-  if (!YGFloatIsUndefined(style_.flexGrow)) {
-    return style_.flexGrow;
+  if (!style_.flexGrow.isUndefined()) {
+    return style_.flexGrow.getValue();
  }
-  if (!YGFloatIsUndefined(style_.flex) && style_.flex > 0.0f) {
-    return style_.flex;
+  if (!style_.flex.isUndefined() && style_.flex.getValue() > 0.0f) {
+    return style_.flex.getValue();
  }
  return kDefaultFlexGrow;
 }

 float YGNode::resolveFlexShrink() {
-  if (parent_ == nullptr) {
+  if (owner_ == nullptr) {
    return 0.0;
  }
-  if (!YGFloatIsUndefined(style_.flexShrink)) {
-    return style_.flexShrink;
+  if (!style_.flexShrink.isUndefined()) {
+    return style_.flexShrink.getValue();
  }
-  if (!config_->useWebDefaults && !YGFloatIsUndefined(style_.flex) &&
-      style_.flex < 0.0f) {
-    return -style_.flex;
+  if (!config_->useWebDefaults && !style_.flex.isUndefined() &&
+      style_.flex.getValue() < 0.0f) {
+    return -style_.flex.getValue();
  }
  return config_->useWebDefaults ? kWebDefaultFlexShrink : kDefaultFlexShrink;
 }
@@ -621,7 +638,7 @@ bool YGNode::isNodeFlexible() {
      (resolveFlexGrow() != 0 || resolveFlexShrink() != 0));
 }

-float YGNode::getLeadingBorder(const YGFlexDirection axis) {
+float YGNode::getLeadingBorder(const YGFlexDirection& axis) const {
  if (YGFlexDirectionIsRow(axis) &&
      style_.border[YGEdgeStart].unit != YGUnitUndefined &&
      !YGFloatIsUndefined(style_.border[YGEdgeStart].value) &&
@@ -634,7 +651,7 @@ float YGNode::getLeadingBorder(const YGFlexDirection axis) {
  return YGFloatMax(computedEdgeValue, 0.0f);
 }

-float YGNode::getTrailingBorder(const YGFlexDirection flexDirection) {
+float YGNode::getTrailingBorder(const YGFlexDirection& flexDirection) const {
  if (YGFlexDirectionIsRow(flexDirection) &&
      style_.border[YGEdgeEnd].unit != YGUnitUndefined &&
      !YGFloatIsUndefined(style_.border[YGEdgeEnd].value) &&
@@ -648,51 +665,52 @@ float YGNode::getTrailingBorder(const YGFlexDirection flexDirection) {
  return YGFloatMax(computedEdgeValue, 0.0f);
 }

-float YGNode::getLeadingPadding(
-    const YGFlexDirection axis,
-    const float widthSize) {
+YGFloatOptional YGNode::getLeadingPadding(
+    const YGFlexDirection& axis,
+    const float& widthSize) const {
+  const YGFloatOptional& paddingEdgeStart =
+      YGResolveValue(style_.padding[YGEdgeStart], widthSize);
  if (YGFlexDirectionIsRow(axis) &&
      style_.padding[YGEdgeStart].unit != YGUnitUndefined &&
-      !YGFloatIsUndefined(
-          YGResolveValue(style_.padding[YGEdgeStart], widthSize)) &&
-      YGResolveValue(style_.padding[YGEdgeStart], widthSize) > 0.0f) {
-    return YGResolveValue(style_.padding[YGEdgeStart], widthSize);
+      !paddingEdgeStart.isUndefined() && paddingEdgeStart.getValue() > 0.0f) {
+    return paddingEdgeStart;
  }

-  float resolvedValue = YGResolveValue(
+  YGFloatOptional resolvedValue = YGResolveValue(
      *YGComputedEdgeValue(style_.padding, leading[axis], &YGValueZero),
      widthSize);
-  return YGFloatMax(resolvedValue, 0.0f);
+  return YGFloatOptionalMax(resolvedValue, YGFloatOptional(0.0f));
 }

-float YGNode::getTrailingPadding(
-    const YGFlexDirection axis,
-    const float widthSize) {
+YGFloatOptional YGNode::getTrailingPadding(
+    const YGFlexDirection& axis,
+    const float& widthSize) const {
  if (YGFlexDirectionIsRow(axis) &&
      style_.padding[YGEdgeEnd].unit != YGUnitUndefined &&
-      !YGFloatIsUndefined(
-          YGResolveValue(style_.padding[YGEdgeEnd], widthSize)) &&
-      YGResolveValue(style_.padding[YGEdgeEnd], widthSize) >= 0.0f) {
+      !YGResolveValue(style_.padding[YGEdgeEnd], widthSize).isUndefined() &&
+      YGResolveValue(style_.padding[YGEdgeEnd], widthSize).getValue() >= 0.0f) {
    return YGResolveValue(style_.padding[YGEdgeEnd], widthSize);
  }

-  float resolvedValue = YGResolveValue(
+  YGFloatOptional resolvedValue = YGResolveValue(
      *YGComputedEdgeValue(style_.padding, trailing[axis], &YGValueZero),
      widthSize);

-  return YGFloatMax(resolvedValue, 0.0f);
+  return YGFloatOptionalMax(resolvedValue, YGFloatOptional(0.0f));
 }

-float YGNode::getLeadingPaddingAndBorder(
-    const YGFlexDirection axis,
-    const float widthSize) {
-  return getLeadingPadding(axis, widthSize) + getLeadingBorder(axis);
+YGFloatOptional YGNode::getLeadingPaddingAndBorder(
+    const YGFlexDirection& axis,
+    const float& widthSize) const {
+  return getLeadingPadding(axis, widthSize) +
+      YGFloatOptional(getLeadingBorder(axis));
 }

-float YGNode::getTrailingPaddingAndBorder(
-    const YGFlexDirection axis,
-    const float widthSize) {
-  return getTrailingPadding(axis, widthSize) + getTrailingBorder(axis);
+YGFloatOptional YGNode::getTrailingPaddingAndBorder(
+    const YGFlexDirection& axis,
+    const float& widthSize) const {
+  return getTrailingPadding(axis, widthSize) +
+      YGFloatOptional(getTrailingBorder(axis));
 }

 bool YGNode::didUseLegacyFlag() {
--- a/yoga/YGNode.h
+++ b/yoga/YGNode.h
@@ -7,6 +7,7 @@

 #pragma once
 #include <stdio.h>
+#include "YGConfig.h"
 #include "YGLayout.h"
 #include "YGStyle.h"
 #include "Yoga-internal.h"
@@ -23,14 +24,16 @@ struct YGNode {
  YGStyle style_;
  YGLayout layout_;
  uint32_t lineIndex_;
-  YGNodeRef parent_;
+  YGNodeRef owner_;
  YGVector children_;
  YGNodeRef nextChild_;
  YGConfigRef config_;
  bool isDirty_;
  std::array<YGValue, 2> resolvedDimensions_;

-  float relativePosition(const YGFlexDirection axis, const float axisSize);
+  YGFloatOptional relativePosition(
+      const YGFlexDirection& axis,
+      const float& axisSize) const;

 public:
  YGNode();
@@ -47,10 +50,10 @@ struct YGNode {
      YGBaselineFunc baseline,
      YGDirtiedFunc dirtied,
      YGStyle style,
-      YGLayout layout,
+      const YGLayout& layout,
      uint32_t lineIndex,
-      YGNodeRef parent,
-      YGVector children,
+      YGNodeRef owner,
+      const YGVector& children,
      YGNodeRef nextChild,
      YGConfigRef config,
      bool isDirty,
@@ -69,7 +72,12 @@ struct YGNode {
  // For Performance reasons passing as reference.
  YGLayout& getLayout();
  uint32_t getLineIndex() const;
-  YGNodeRef getParent() const;
+  // returns the YGNodeRef that owns this YGNode. An owner is used to identify
+  // the YogaTree that a YGNode belongs to.
+  // This method will return the parent of the YGNode when a YGNode only belongs
+  // to one YogaTree or nullptr when the YGNode is shared between two or more
+  // YogaTrees.
+  YGNodeRef getOwner() const;
  YGVector getChildren() const;
  uint32_t getChildrenCount() const;
  YGNodeRef getChild(uint32_t index) const;
@@ -80,23 +88,36 @@ struct YGNode {
  YGValue getResolvedDimension(int index);

  // Methods related to positions, margin, padding and border
-  float getLeadingPosition(const YGFlexDirection axis, const float axisSize);
-  bool isLeadingPositionDefined(const YGFlexDirection axis);
-  bool isTrailingPosDefined(const YGFlexDirection axis);
-  float getTrailingPosition(const YGFlexDirection axis, const float axisSize);
-  float getLeadingMargin(const YGFlexDirection axis, const float widthSize);
-  float getTrailingMargin(const YGFlexDirection axis, const float widthSize);
-  float getLeadingBorder(const YGFlexDirection flexDirection);
-  float getTrailingBorder(const YGFlexDirection flexDirection);
-  float getLeadingPadding(const YGFlexDirection axis, const float widthSize);
-  float getTrailingPadding(const YGFlexDirection axis, const float widthSize);
-  float getLeadingPaddingAndBorder(
-      const YGFlexDirection axis,
-      const float widthSize);
-  float getTrailingPaddingAndBorder(
-      const YGFlexDirection axis,
-      const float widthSize);
-  float getMarginForAxis(const YGFlexDirection axis, const float widthSize);
+  YGFloatOptional getLeadingPosition(const YGFlexDirection& axis,
+      const float& axisSize) const;
+  bool isLeadingPositionDefined(const YGFlexDirection& axis) const;
+  bool isTrailingPosDefined(const YGFlexDirection& axis) const;
+  YGFloatOptional getTrailingPosition(
+      const YGFlexDirection& axis,
+      const float& axisSize) const;
+  YGFloatOptional getLeadingMargin(
+      const YGFlexDirection& axis,
+      const float& widthSize) const;
+  YGFloatOptional getTrailingMargin(
+      const YGFlexDirection& axis,
+      const float& widthSize) const;
+  float getLeadingBorder(const YGFlexDirection& flexDirection) const;
+  float getTrailingBorder(const YGFlexDirection& flexDirection) const;
+  YGFloatOptional getLeadingPadding(
+      const YGFlexDirection& axis,
+      const float& widthSize) const;
+  YGFloatOptional getTrailingPadding(
+      const YGFlexDirection& axis,
+      const float& widthSize) const;
+  YGFloatOptional getLeadingPaddingAndBorder(
+      const YGFlexDirection& axis,
+      const float& widthSize) const;
+  YGFloatOptional getTrailingPaddingAndBorder(
+      const YGFlexDirection& axis,
+      const float& widthSize) const;
+  YGFloatOptional getMarginForAxis(
+      const YGFlexDirection& axis,
+      const float& widthSize) const;
  // Setters

  void setContext(void* context);
@@ -106,18 +127,18 @@ struct YGNode {
  void setMeasureFunc(YGMeasureFunc measureFunc);
  void setBaseLineFunc(YGBaselineFunc baseLineFunc);
  void setDirtiedFunc(YGDirtiedFunc dirtiedFunc);
-  void setStyle(YGStyle style);
+  void setStyle(const YGStyle& style);
  void setStyleFlexDirection(YGFlexDirection direction);
  void setStyleAlignContent(YGAlign alignContent);
-  void setLayout(YGLayout layout);
+  void setLayout(const YGLayout& layout);
  void setLineIndex(uint32_t lineIndex);
-  void setParent(YGNodeRef parent);
-  void setChildren(YGVector children);
+  void setOwner(YGNodeRef owner);
+  void setChildren(const YGVector& children);
  void setNextChild(YGNodeRef nextChild);
  void setConfig(YGConfigRef config);
  void setDirty(bool isDirty);
-  void setLayoutLastParentDirection(YGDirection direction);
-  void setLayoutComputedFlexBasis(float computedFlexBasis);
+  void setLayoutLastOwnerDirection(YGDirection direction);
+  void setLayoutComputedFlexBasis(const YGFloatOptional& computedFlexBasis);
  void setLayoutComputedFlexBasisGeneration(
      uint32_t computedFlexBasisGeneration);
  void setLayoutMeasuredDimension(float measuredDimension, int index);
@@ -132,7 +153,7 @@ struct YGNode {
      const YGDirection direction,
      const float mainSize,
      const float crossSize,
-      const float parentWidth);
+      const float ownerWidth);
  void setAndPropogateUseLegacyFlag(bool useLegacyFlag);
  void setLayoutDoesLegacyFlagAffectsLayout(bool doesLegacyFlagAffectsLayout);
  void setLayoutDidUseLegacyFlag(bool didUseLegacyFlag);
@@ -143,7 +164,7 @@ struct YGNode {
  YGValue marginTrailingValue(const YGFlexDirection axis) const;
  YGValue resolveFlexBasisPtr() const;
  void resolveDimension();
-  YGDirection resolveDirection(const YGDirection parentDirection);
+  YGDirection resolveDirection(const YGDirection ownerDirection);
  void clearChildren();
  /// Replaces the occurrences of oldChild with newChild
  void replaceChild(YGNodeRef oldChild, YGNodeRef newChild);
--- a/yoga/YGNodePrint.cpp
+++ b/yoga/YGNodePrint.cpp
@@ -39,10 +39,12 @@ static void appendFormatedString(string* str, const char* fmt, ...) {
  str->append(result);
 }

-static void
-appendFloatIfNotUndefined(string* base, const string key, const float num) {
-  if (!YGFloatIsUndefined(num)) {
-    appendFormatedString(base, "%s: %g; ", key.c_str(), num);
+static void appendFloatOptionalIfDefined(
+    string* base,
+    const string key,
+    const YGFloatOptional num) {
+  if (!num.isUndefined()) {
+    appendFormatedString(base, "%s: %g; ", key.c_str(), num.getValue());
  }
 }

@@ -70,7 +72,10 @@ appendNumberIfNotAuto(string* base, const string& key, const YGValue number) {

 static void
 appendNumberIfNotZero(string* base, const string& str, const YGValue number) {
-  if (!YGFloatsEqual(number.value, 0)) {
+
+  if (number.unit == YGUnitAuto) {
+    base->append(str + ": auto; ");
+  } else if (!YGFloatsEqual(number.value, 0)) {
    appendNumberIfNotUndefined(base, str, number);
  }
 }
@@ -152,10 +157,11 @@ void YGNodeToString(
      appendFormatedString(
          str, "align-self: %s; ", YGAlignToString(node->getStyle().alignSelf));
    }
-    appendFloatIfNotUndefined(str, "flex-grow", node->getStyle().flexGrow);
-    appendFloatIfNotUndefined(str, "flex-shrink", node->getStyle().flexShrink);
+    appendFloatOptionalIfDefined(str, "flex-grow", node->getStyle().flexGrow);
+    appendFloatOptionalIfDefined(
+        str, "flex-shrink", node->getStyle().flexShrink);
    appendNumberIfNotAuto(str, "flex-basis", node->getStyle().flexBasis);
-    appendFloatIfNotUndefined(str, "flex", node->getStyle().flex);
+    appendFloatOptionalIfDefined(str, "flex", node->getStyle().flex);

    if (node->getStyle().flexWrap != YGNode().getStyle().flexWrap) {
      appendFormatedString(
--- a/yoga/YGStyle.cpp
+++ b/yoga/YGStyle.cpp
@@ -7,9 +7,9 @@

 #include "YGStyle.h"

-const YGValue kYGValueUndefined = {YGUndefined, YGUnitUndefined};
+const YGValue kYGValueUndefined = {0, YGUnitUndefined};

-const YGValue kYGValueAuto = {YGUndefined, YGUnitAuto};
+const YGValue kYGValueAuto = {0, YGUnitAuto};

 const std::array<YGValue, YGEdgeCount> kYGDefaultEdgeValuesUnit = {
    {kYGValueUndefined,
@@ -39,9 +39,9 @@ YGStyle::YGStyle()
      flexWrap(YGWrapNoWrap),
      overflow(YGOverflowVisible),
      display(YGDisplayFlex),
-      flex(YGUndefined),
-      flexGrow(YGUndefined),
-      flexShrink(YGUndefined),
+      flex(YGFloatOptional()),
+      flexGrow(YGFloatOptional()),
+      flexShrink(YGFloatOptional()),
      flexBasis(kYGValueAuto),
      margin(kYGDefaultEdgeValuesUnit),
      position(kYGDefaultEdgeValuesUnit),
@@ -50,7 +50,7 @@ YGStyle::YGStyle()
      dimensions(kYGDefaultDimensionValuesAutoUnit),
      minDimensions(kYGDefaultDimensionValuesUnit),
      maxDimensions(kYGDefaultDimensionValuesUnit),
-      aspectRatio(YGUndefined) {}
+      aspectRatio(YGFloatOptional()) {}

 // Yoga specific properties, not compatible with flexbox specification
 bool YGStyle::operator==(const YGStyle& style) {
@@ -69,25 +69,31 @@ bool YGStyle::operator==(const YGStyle& style) {
      YGValueArrayEqual(minDimensions, style.minDimensions) &&
      YGValueArrayEqual(maxDimensions, style.maxDimensions);

-  if (!(YGFloatIsUndefined(flex) && YGFloatIsUndefined(style.flex))) {
-    areNonFloatValuesEqual = areNonFloatValuesEqual && flex == style.flex;
+  areNonFloatValuesEqual =
+      areNonFloatValuesEqual && flex.isUndefined() == style.flex.isUndefined();
+  if (areNonFloatValuesEqual && !flex.isUndefined() &&
+      !style.flex.isUndefined()) {
+    areNonFloatValuesEqual =
+        areNonFloatValuesEqual && flex.getValue() == style.flex.getValue();
  }

-  if (!(YGFloatIsUndefined(flexGrow) && YGFloatIsUndefined(style.flexGrow))) {
-    areNonFloatValuesEqual =
-        areNonFloatValuesEqual && flexGrow == style.flexGrow;
+  areNonFloatValuesEqual = areNonFloatValuesEqual &&
+      flexGrow.isUndefined() == style.flexGrow.isUndefined();
+  if (areNonFloatValuesEqual && !flexGrow.isUndefined()) {
+    areNonFloatValuesEqual = areNonFloatValuesEqual &&
+        flexGrow.getValue() == style.flexGrow.getValue();
  }

-  if (!(YGFloatIsUndefined(flexShrink) &&
-        YGFloatIsUndefined(style.flexShrink))) {
-    areNonFloatValuesEqual =
-        areNonFloatValuesEqual && flexShrink == style.flexShrink;
+  areNonFloatValuesEqual = areNonFloatValuesEqual &&
+      flexShrink.isUndefined() == style.flexShrink.isUndefined();
+  if (areNonFloatValuesEqual && !style.flexShrink.isUndefined()) {
+    areNonFloatValuesEqual = areNonFloatValuesEqual &&
+        flexShrink.getValue() == style.flexShrink.getValue();
  }

-  if (!(YGFloatIsUndefined(aspectRatio) &&
-        YGFloatIsUndefined(style.aspectRatio))) {
-    areNonFloatValuesEqual =
-        areNonFloatValuesEqual && aspectRatio == style.aspectRatio;
+  if (!(aspectRatio.isUndefined() && style.aspectRatio.isUndefined())) {
+    areNonFloatValuesEqual = areNonFloatValuesEqual &&
+        aspectRatio.getValue() == style.aspectRatio.getValue();
  }

  return areNonFloatValuesEqual;
--- a/yoga/YGStyle.h
+++ b/yoga/YGStyle.h
@@ -6,6 +6,7 @@
 */

 #pragma once
+#include "YGFloatOptional.h"
 #include "Yoga-internal.h"
 #include "Yoga.h"

@@ -20,9 +21,9 @@ struct YGStyle {
  YGWrap flexWrap;
  YGOverflow overflow;
  YGDisplay display;
-  float flex;
-  float flexGrow;
-  float flexShrink;
+  YGFloatOptional flex;
+  YGFloatOptional flexGrow;
+  YGFloatOptional flexShrink;
  YGValue flexBasis;
  std::array<YGValue, YGEdgeCount> margin;
  std::array<YGValue, YGEdgeCount> position;
@@ -31,7 +32,7 @@ struct YGStyle {
  std::array<YGValue, 2> dimensions;
  std::array<YGValue, 2> minDimensions;
  std::array<YGValue, 2> maxDimensions;
-  float aspectRatio;
+  YGFloatOptional aspectRatio;

  YGStyle();
  // Yoga specific properties, not compatible with flexbox specification
--- a/yoga/Yoga-internal.h
+++ b/yoga/Yoga-internal.h
@@ -87,16 +87,6 @@ struct YGCachedMeasurement {
 // layouts should not require more than 16 entries to fit within the cache.
 #define YG_MAX_CACHED_RESULT_COUNT 16

-struct YGConfig {
-  bool experimentalFeatures[YGExperimentalFeatureCount + 1];
-  bool useWebDefaults;
-  bool useLegacyStretchBehaviour;
-  bool shouldDiffLayoutWithoutLegacyStretchBehaviour;
-  float pointScaleFactor;
-  YGLogger logger;
-  YGNodeClonedFunc cloneNodeCallback;
-  void* context;
-};

 static const float kDefaultFlexGrow = 0.0f;
 static const float kDefaultFlexShrink = 0.0f;
--- a/yoga/Yoga.cpp
+++ b/yoga/Yoga.cpp
--- a/yoga/Yoga.h
+++ b/yoga/Yoga.h
@@ -62,10 +62,8 @@ typedef int (*YGLogger)(const YGConfigRef config,
                        YGLogLevel level,
                        const char *format,
                        va_list args);
-typedef void (*YGNodeClonedFunc)(YGNodeRef oldNode,
-                                 YGNodeRef newNode,
-                                 YGNodeRef parent,
-                                 int childIndex);
+typedef YGNodeRef (
+    *YGCloneNodeFunc)(YGNodeRef oldNode, YGNodeRef owner, int childIndex);

 // YGNode
 WIN_EXPORT YGNodeRef YGNodeNew(void);
@@ -79,16 +77,31 @@ WIN_EXPORT int32_t YGNodeGetInstanceCount(void);
 WIN_EXPORT void YGNodeInsertChild(const YGNodeRef node,
                                  const YGNodeRef child,
                                  const uint32_t index);
+
+// This function inserts the child YGNodeRef as a children of the node received
+// by parameter and set the Owner of the child object to null. This function is
+// expected to be called when using Yoga in persistent mode in order to share a
+// YGNodeRef object as a child of two different Yoga trees. The child YGNodeRef
+// is expected to be referenced from its original owner and from a clone of its
+// original owner.
+WIN_EXPORT void YGNodeInsertSharedChild(
+    const YGNodeRef node,
+    const YGNodeRef child,
+    const uint32_t index);
 WIN_EXPORT void YGNodeRemoveChild(const YGNodeRef node, const YGNodeRef child);
 WIN_EXPORT void YGNodeRemoveAllChildren(const YGNodeRef node);
 WIN_EXPORT YGNodeRef YGNodeGetChild(const YGNodeRef node, const uint32_t index);
-WIN_EXPORT YGNodeRef YGNodeGetParent(const YGNodeRef node);
+WIN_EXPORT YGNodeRef YGNodeGetOwner(const YGNodeRef node);
 WIN_EXPORT uint32_t YGNodeGetChildCount(const YGNodeRef node);
+WIN_EXPORT void YGNodeSetChildren(
+    YGNodeRef const owner,
+    const YGNodeRef children[],
+    const uint32_t count);

 WIN_EXPORT void YGNodeCalculateLayout(const YGNodeRef node,
                                      const float availableWidth,
                                      const float availableHeight,
-                                      const YGDirection parentDirection);
+                                      const YGDirection ownerDirection);

 // Mark a node as dirty. Only valid for nodes with a custom measure function
 // set.
@@ -190,7 +203,6 @@ YG_NODE_STYLE_PROPERTY(YGPositionType, PositionType, positionType);
 YG_NODE_STYLE_PROPERTY(YGWrap, FlexWrap, flexWrap);
 YG_NODE_STYLE_PROPERTY(YGOverflow, Overflow, overflow);
 YG_NODE_STYLE_PROPERTY(YGDisplay, Display, display);
-
 YG_NODE_STYLE_PROPERTY(float, Flex, flex);
 YG_NODE_STYLE_PROPERTY(float, FlexGrow, flexGrow);
 YG_NODE_STYLE_PROPERTY(float, FlexShrink, flexShrink);
@@ -232,6 +244,7 @@ YG_NODE_LAYOUT_PROPERTY(float, Width);
 YG_NODE_LAYOUT_PROPERTY(float, Height);
 YG_NODE_LAYOUT_PROPERTY(YGDirection, Direction);
 YG_NODE_LAYOUT_PROPERTY(bool, HadOverflow);
+bool YGNodeLayoutGetDidLegacyStretchFlagAffectLayout(const YGNodeRef node);

 // Get the computed values for these nodes after performing layout. If they were set using
 // point values then the returned value will be the same as YGNodeStyleGetXXX. However if
@@ -249,10 +262,12 @@ WIN_EXPORT void YGAssertWithNode(const YGNodeRef node, const bool condition, con
 WIN_EXPORT void YGAssertWithConfig(const YGConfigRef config,
                                   const bool condition,
                                   const char *message);
-
 // Set this to number of pixels in 1 point to round calculation results
 // If you want to avoid rounding - set PointScaleFactor to 0
 WIN_EXPORT void YGConfigSetPointScaleFactor(const YGConfigRef config, const float pixelsInPoint);
+void YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour(
+    const YGConfigRef config,
+    const bool shouldDiffLayout);

 // Yoga previously had an error where containers would take the maximum space possible instead of
 // the minimum
@@ -280,8 +295,8 @@ WIN_EXPORT bool YGConfigIsExperimentalFeatureEnabled(const YGConfigRef config,
 WIN_EXPORT void YGConfigSetUseWebDefaults(const YGConfigRef config, const bool enabled);
 WIN_EXPORT bool YGConfigGetUseWebDefaults(const YGConfigRef config);

-WIN_EXPORT void YGConfigSetNodeClonedFunc(const YGConfigRef config,
-                                          const YGNodeClonedFunc callback);
+WIN_EXPORT void YGConfigSetCloneNodeFunc(const YGConfigRef config,
+                                          const YGCloneNodeFunc callback);

 // Export only for C#
 WIN_EXPORT YGConfigRef YGConfigGetDefault(void);
@@ -296,3 +311,17 @@ WIN_EXPORT float YGRoundValueToPixelGrid(
    const bool forceFloor);

 YG_EXTERN_C_END
+
+#ifdef __cplusplus
+
+#include <functional>
+#include <vector>
+
+// Calls f on each node in the tree including the given node argument.
+extern void YGTraversePreOrder(YGNodeRef const node, std::function<void(YGNodeRef node)>&& f);
+
+extern void YGNodeSetChildren(
+    YGNodeRef const owner,
+    const std::vector<YGNodeRef>& children);
+
+#endif
--- a/yoga_defs.bzl
+++ b/yoga_defs.bzl
@@ -32,6 +32,7 @@ BASE_COMPILER_FLAGS = [
  '-Wall',
  '-Werror',
  '-O3',
+  '-ffast-math',
 ]

 LIBRARY_COMPILER_FLAGS = BASE_COMPILER_FLAGS + [
@@ -112,4 +113,3 @@ def prebuilt_jar(*args, **kwargs):

 def is_apple_platform():
  return True
-
Author	SHA1	Message	Date
Pascal Hartig	adb1b11055	1.8.0 Summary: New release. Reviewed By: marco-cova Differential Revision: D7550852 fbshipit-source-id: eac5662179daa88d9d62c55566b3a31428c4117a	2018-04-09 02:41:21 -07:00
David Vacca	2e234473ca	[yoga re-add assertion to check for owner reference before adding child. Summary: this diff re-add the assertion to check for owner reference before adding child that was removed by mistake in previous diff Reviewed By: emilsjolander Differential Revision: D7495417 fbshipit-source-id: b81174aeea3f2796d76ccdae4a8eddd0beace0aa	2018-04-04 10:57:52 -07:00
Lukas Wöhrl	6b08db68bb	Fix compilation on MSVC by moving YGConfig to C++ Summary: This PR fixes the compilation on MSVC. I moved the `YGConfig` creation to a C++ constructor. Addionally it removes the "dot" notation on `YGValue`, I didn't want to change that type to a C++ constructor, because I think this will break the ABI. Closes https://github.com/facebook/yoga/pull/746 Differential Revision: D7498141 Pulled By: emilsjolander fbshipit-source-id: 5f5308ff838dcd803065785ddc08b2404524acb9	2018-04-04 09:55:45 -07:00
Pritesh Nandgaonkar	9550126f76	clean up experimental setup and keep using ffast-math flag Summary: Remove experimental setup of fast-math and add `-ffast-math` as a compiler flag for yoga. Reviewed By: emilsjolander Differential Revision: D7414228 fbshipit-source-id: 320e1b1953f6af867b13e617af7872eb8999160e	2018-04-04 08:29:43 -07:00
Pritesh Nandgaonkar	bad262b961	Change the return type of getMarginForAxis to YGFloatOptional Summary: Change the return type of getMarginForAxis to YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7350337 fbshipit-source-id: dd1ee2fcd295ccd14f7d414ab0c24090b24e91e0	2018-04-04 08:29:43 -07:00
Pritesh Nandgaonkar	3c6c10075a	Change the return type of getTrailingMargin to YGFloatOptional Summary: Change the return type of getTrailingMargin to YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7350221 fbshipit-source-id: 61a67364c1975ec6dd1883bc2cb4968b830c73df	2018-04-04 08:29:43 -07:00
Pritesh Nandgaonkar	6a77a6939e	Changed the return type of getLeadingMargin to YGFloatOptional Summary: Changed the return type of getLeadingMargin to YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7349907 fbshipit-source-id: b20894fbc33fd5b29a28f3c9174d1b5f406774ab	2018-04-04 08:29:43 -07:00
Pritesh Nandgaonkar	b725a4a140	Refactored relativePosition private method to YGFloatOptional return type Summary: Refactored relativePosition private method to YGFloatOptional return type Reviewed By: emilsjolander Differential Revision: D7344939 fbshipit-source-id: 72443d38426a211d3e84be814e6a61baf4d26703	2018-04-04 08:29:43 -07:00
Pritesh Nandgaonkar	2b714a5b5d	Change the type of getTrailingPosition to YGFloatOptional Summary: Change the type of getTrailingPosition to YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7344710 fbshipit-source-id: eb4c422b6e0f55d90b083221aa8ff1ab797d58a8	2018-04-04 08:29:43 -07:00
Pritesh Nandgaonkar	572546088f	Changed the type of return value of getLeadingPosition to YGFloatOptional Summary: Changed the type of return value of getLeadingPosition to YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7344367 fbshipit-source-id: 0f5a667ca357b2ce056c86763aa3e9e4c54b82f0	2018-04-04 08:29:43 -07:00
Pritesh Nandgaonkar	5b109578d3	Changed the type of computedFlexBasis to YGFloatOptional in YGLayout Summary: Changed the type of computedFlexBasis to YGFloatOptional in YGLayout Reviewed By: emilsjolander Differential Revision: D7340413 fbshipit-source-id: 39247b2b582a682e602f49f58b4bbd2bf0c995af	2018-04-04 08:29:43 -07:00
Pritesh Nandgaonkar	77b720f9a5	Fixed types of getLeadingPaddingAndBorder and getTrailingPaddingAndBorder to YGFloatOptional Summary: Fixed types of getLeadingPaddingAndBorder and getTrailingPaddingAndBorder to YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7339998 fbshipit-source-id: aa24335c2db1cd895b9711214b72195add718c32	2018-04-04 08:29:43 -07:00
Pritesh Nandgaonkar	de954eb9cc	Changed the return type of trailing padding to YGFloatOptional Summary: Changed the return type of trailing padding to YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7339712 fbshipit-source-id: 483c5886838c14b17cb731c81abb9fc80f519956	2018-04-04 08:29:42 -07:00
Pritesh Nandgaonkar	3e322e60e4	Updated the implementation of leading padding Summary: Changed the arguments for the getter of leading padding to avoid copies. Added an assetion in getter of leading padding, as padding would always be defined even in the case when the user has not explicitly defined the value. In these cases it would take the default value of 0. So changing the type of `getLayoutPadding` to `YGFloatOptional`, doesn't make sense. Reviewed By: emilsjolander Differential Revision: D7336690 fbshipit-source-id: b2a2f010026f26fc2cc9fb35ad921da8f7017c9f	2018-04-04 08:29:42 -07:00
Pritesh Nandgaonkar	a3642541d0	Make the return type of YGNodeBoundAxisWithinMinAndMax to YGFloatOptional Summary: Make the return type of YGNodeBoundAxisWithinMinAndMax to YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7323382 fbshipit-source-id: 8e3eb4f3744b5f3f9e2b353f56184905f7557191	2018-04-04 08:29:42 -07:00
Pritesh Nandgaonkar	bb139d3f91	Remove the use of YGUnwrapOptional from YGConstrainedMaxSizeForMode Summary: Remove the use of YGUnwrapOptional from YGConstrainedMaxSizeForMode Reviewed By: emilsjolander Differential Revision: D7322743 fbshipit-source-id: d825c60bcdc9ecdc0c784a215dc6b1b8a7a7860e	2018-04-04 08:29:42 -07:00
Pritesh Nandgaonkar	08743a42e2	Made the acccessors method to return const references Summary: Made the acccessors method to return const references Reviewed By: emilsjolander Differential Revision: D7321801 fbshipit-source-id: 9fc4da724bc2f58a0d95824ca3c0b5bf1690bccf	2018-04-04 08:29:42 -07:00
Lukas Wöhrl	cb6e76973d	Fix float type mismatch on endOfLineIndex and inside rounding Summary: This PR fixes a type mismatch on `endOfLineIndex` where it should be of type `uint32_t` while it is of type `float` Additonally it fixes some `double` casting in the rounding methods. Closes https://github.com/facebook/yoga/pull/745 Differential Revision: D7494519 Pulled By: emilsjolander fbshipit-source-id: 30a86574ce163458a6888f61a902d0640c1874fb	2018-04-04 07:04:23 -07:00
Pritesh Nandgaonkar	4b760fa9bc	Changed the return type of YGResolveValueMargin to YGFloatOptional Summary: Changed the return type of YGResolveValueMargin to YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7304090 fbshipit-source-id: cbec03a9367cf34976d083ad475d4da0b736e6d2	2018-04-03 15:12:07 -07:00
Pritesh Nandgaonkar	5730be093e	Move equaltiy function from utils to an operator on YGFloatOptional Summary: Move equaltiy function from utils to an operator on YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7303460 fbshipit-source-id: 41ec0076ace621ec1a5bdbab00b72eea57780fff	2018-04-03 15:12:05 -07:00
Pritesh Nandgaonkar	d85e2ee9c3	Change the type of aspect Ratio to YGFloatOptional Summary: Change the type of aspect Ratio to YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7302651 fbshipit-source-id: 53e3b4c9627207a379f927b1f3485e36a9c70601	2018-04-03 15:12:02 -07:00
Pritesh Nandgaonkar	fe433b012f	Remove the usage of YGUndefined for kYGValueAuto and fix setter and getter of dimensions Summary: Removes the use of YGUndefined from kYGValueAuto. Also fixed the setter and getter of dimensions. This diff also fixes a typo Reviewed By: emilsjolander Differential Revision: D7302453 fbshipit-source-id: e002a1ddd75bfc6fe142a7275e7913c064972e16	2018-04-03 15:11:58 -07:00
David Vacca	5e3ffb39a2	Extend Yoga to be able clone Yoga Node with new children Summary: This diff includes the following changes: 1 ) I extended the Java implementation of YogaNode to be able to get a full copy of a YogaNode object without copying the List of children of the original YogaNode. In other words, the new copy of the YogaNode will have the same data of the original YogaNode, but with an empty list of children. 2 ) We created a new method in Yoga.cpp called YGNodeInsertSharedChild. This new method is going to be used by Fabric in order to temporarily share a YogaNode between two "Yoga Trees" (the "current Yoga" tree and a partial "clone of the current Yoga tree"). We exposed this new functionality in the java implementation of Yoga (method addSharedChildAt) I'm including sebmarkbage for more context. Reviewed By: emilsjolander Differential Revision: D7245421 fbshipit-source-id: 72578c8261f29e4a12fc6c72a91f2f891cd58d48	2018-04-01 18:35:13 -07:00
David Vacca	f0edefdbb7	Rename YogaNode.parent -> YogaNode.owner Summary: In the persistent version of Yoga, a YogaNode can be shared between two YogaTrees, that means that a YogaNode could have more than one Parent at one point in time. That's why the concept of Parent of a YogaNode is not a 1-1 relationship anymore. This diff changes the semantic of Parent of a YogaNode to Owner of a Yoga Node. CC sebmarkbage and priteshrnandgaonkar for more context. Technically this diff renames the field YogaNode.parent to YogaNode.owner (and every internal field, Getter and Setter that is related to parent) Note that as part of this diff I also modified the CSSLayoutDEPRECATED version of Yoga in order to keep compatibility with the C++ implementation. Reviewed By: priteshrnandgaonkar Differential Revision: D7352778 fbshipit-source-id: dcf1af5e72bfc3063b5c4bda197d7952a9194768	2018-04-01 18:35:13 -07:00
David Vacca	17901ea5c2	Refactor cloning of YogaNode Summary: see Test Plan Reviewed By: priteshrnandgaonkar Differential Revision: D7339832 fbshipit-source-id: 2de6f47ae7601ac083d3b9fbe10ffaf6307ae760	2018-04-01 18:35:13 -07:00
Jonathan Dann	187fc54596	Add YGNodeSetChildren(), YGNodeTraversePreOrder() Summary: We had functions for inserting/removing a specific child, but not for simply replacing the child set with another list. `YGNodeSetChildren()` will unhook child nodes from the parent that don't appear in the new set. We set the disconnected child node layouts to `YGLayout()` b/c that's what the rest of the code does. `YGTraversePreOrder()` walks the tree and calls a labmda for each node. We could very easily add a post-order traversal and the ability to stop traversal if we ever want, but for now this is an MVP. Reviewed By: Woody17 Differential Revision: D7360203 fbshipit-source-id: 32df8e1213ead03bc0a026ec4bf453bc799bb9ce	2018-03-25 13:59:44 -07:00
Pritesh Nandgaonkar	c951ad7c7b	Push Yoga 1.8.0 to cocoapods Summary: Podspec to push yoga 1.8.0 to cocoapods. There is an issue with cocoapods and it fails to lint those projects with C++ in its header, which is the case with yoga too. Follow this thread https://github.com/CocoaPods/CocoaPods/issues/5152. To make the lint pass, one would have to change `app_target_helper.rb` cocoapod source file in the local machine. Follow my [gist](https://gist.github.com/priteshrnandgaonkar/dcca9639a3bc0a3b9adecae3a2b3b0c4). I am able to pass the lint, but not able to push the pod in cocoapods as I am not the admin. @[759512522:emilsj], please push it on Cocoapods or give me permission. Podspec now also exposes public header explicitly. Reviewed By: gkassabli Differential Revision: D7375018 fbshipit-source-id: 4e82e1c0b6340c3f8d3b8a96ecadbcb711d4bcd8	2018-03-23 05:33:59 -07:00
Daniel Büchele	9785975f77	add documentation about JS library usage. fixes #733 Summary: Adds an example of how to use yoga from JavaScript to the documentation pages. Reviewed By: priteshrnandgaonkar Differential Revision: D7354390 fbshipit-source-id: 0dbc08e5341c06b621acd99bfb9ce7e789b67a45	2018-03-22 04:53:24 -07:00
Jonathan Dann	79281049f2	Mark more member functions as const Summary: These don't mutate internal state. Reviewed By: priteshrnandgaonkar Differential Revision: D7291364 fbshipit-source-id: 2e7d96cfe0345692ffa411bb21a80eb7a859880b	2018-03-21 16:14:21 -07:00
Jonathan Dann	7d2b84aab6	Pass some constructor argumetns by const-reference Summary: These don't need to be copied twice. Reviewed By: priteshrnandgaonkar Differential Revision: D7291363 fbshipit-source-id: 22e606d0b3fa1133d7e0334c8cf9f5f1f32fe64b	2018-03-21 16:14:21 -07:00
Jonathan Dann	cda328fa7e	Pass-by-reference in YGNode::setStyle() ::setChildren() ::setLayout() Summary: These shouldn't be copying the arguments when they pass by value. Instead these only get copied when assigning the value to the member. Reviewed By: priteshrnandgaonkar Differential Revision: D7291096 fbshipit-source-id: 7a4025831811d622050adbb5f86608855b94d68e	2018-03-21 16:14:20 -07:00
Pritesh Nandgaonkar	5d7b75a47a	Moved YGFloatOptional from C struct to C++ struct Summary: Earlier `YGfloatOptional` was plain struct with no privacy around the variables. This diff adds privacy and also enforces checks when one tries to access value of an undefined `YGFloatOptional` This diff also adds a behaviour in which when a value of an undefined YGFloatOptional is accessed, it will normally terminate(Several cleanup steps are performed). Reviewed By: emilsjolander Differential Revision: D7288555 fbshipit-source-id: f61cc92c8fd0d48d2fc1f4d0e6fcef155f19ff8a	2018-03-15 13:04:51 -07:00
Pritesh Nandgaonkar	ae86824636	Fixed a typo and added a test case Summary: Fixed a typo of flexshrink and added a test case Reviewed By: emilsjolander Differential Revision: D7289221 fbshipit-source-id: 48ee9ccfac4adee51d515a366b5a11790f7236fc	2018-03-15 13:04:51 -07:00
Pritesh Nandgaonkar	0dde40ce0b	Fix getters and setters if min and max Dimension Summary: Fix getters and setters of min and max Dimension to behave exactly the same way as it was before fast math changes Reviewed By: emilsjolander Differential Revision: D7274807 fbshipit-source-id: 7c1a4c19e8d0552b089a410c3330392cb26a6a47	2018-03-15 07:27:55 -07:00
Pritesh Nandgaonkar	369c9ad12a	Fix setter and getter of margin, position, border and padding Summary: This diff fixes the setter and getter of margin, position, border and padding to the previous behaviour of yoga, before floatoptional change This diff also removes the unrequired `#define` Reviewed By: emilsjolander Differential Revision: D7274115 fbshipit-source-id: 942a91e6562ef789ae79102a828f397889468fa7	2018-03-15 07:27:55 -07:00
Pritesh Nandgaonkar	cfb9eeca20	Fix failing float max test Summary: Earlier YGUndefined was NAN, but recently it was replaced with 10E20 and the check for `isUndefined` is as follows ``` public static boolean isUndefined(float value) { return (Float.compare(value, (float) 10E8) >= 0 \|\| Float.compare(value, (float) -10E8) <= 0); } ``` If the number is in (-inf, -10E8] and [10E8, inf) then it is considered as undefined. Failing test passed values in this range, so thats why the test was failing. Current diff fixes this issue, and passes a big number which is outside the range as the result of measure function. Reviewed By: emilsjolander Differential Revision: D7272325 fbshipit-source-id: 81a77117c65c5dc0cec920f50f0735ec0a7433d1	2018-03-14 09:21:15 -07:00
Pritesh Nandgaonkar	3dfb68887d	Expose layout diffing flag to java Summary: This diff exposes `shouldDiffLayoutWithoutLegacyStretchBehaviour` from YGConfig and `doesLegacyStretchFlagAffectsLayout` from YGLayout to YogaConfig and YogaNode respectively Also added a positive test case. Didn't find the negative test case example. @[508947467:ianc] or @[759512522:emilsj], can you suggest a negative test case example. Reviewed By: emilsjolander Differential Revision: D7272067 fbshipit-source-id: e67e82eb057e4c7124904c715f9dca4dcfea21ea	2018-03-14 08:43:01 -07:00
Pritesh Nandgaonkar	d567885070	Remove the use of YGUndefined for flex-basis Summary: Remove the use of YGUndefined for default flex-basis value Reviewed By: emilsjolander Differential Revision: D7243924 fbshipit-source-id: 2bfaca1a5e3da40d5292a273cabf705f59c9d666	2018-03-14 04:36:53 -07:00
Pritesh Nandgaonkar	877c275a13	Change the type of flexShrink to YGFloatOptional Summary: Change the type of flexShrink to YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7232171 fbshipit-source-id: 3111119d3d74a7035c01132bff61b30cf44e120a	2018-03-14 04:36:53 -07:00
Pritesh Nandgaonkar	8aadae8ce4	Change the type of flexGrow to YGFloatOptional Summary: Change the type of flexGrow to YGFloatOptional Reviewed By: emilsjolander Differential Revision: D7215355 fbshipit-source-id: 1298ee332551d44e4d070169a1e4103d005c4f43	2018-03-14 04:36:53 -07:00
Pritesh Nandgaonkar	2232d7603a	Change the type of flex to YGFloatOptional Summary: Change the type of flex to YGFloatOptional internally, but keeping the public facing API the same as before Reviewed By: emilsjolander Differential Revision: D7211327 fbshipit-source-id: 0d979b6ba00317317b98bbc6e63979c7f1feb2da	2018-03-14 04:36:52 -07:00
Pritesh Nandgaonkar	b3f8851bc2	Changed the return type of YGResolveValue Summary: Changed the return type of YGResolveValue Reviewed By: emilsjolander Differential Revision: D7195099 fbshipit-source-id: 72c4163cd08691cf6e40df05394cc52e83b0de14	2018-03-14 04:36:52 -07:00
Pritesh Nandgaonkar	47ad3f63cf	Remove the usage of YGUndefined in the default values of Border in YGStyle Summary: Remove the usage of YGUndefined in the default values of Border in YGStyle. In the getter of Border function, YGUndefined is used just to keep it logically consistent. The proper solution would be to change the api in `Yoga.h` to accept `YGFloatOptional`, but that would require to change lot of the code in client of this library. Will make a separate diff for that. Reviewed By: emilsjolander Differential Revision: D7195115 fbshipit-source-id: e635cf55ac94d8a90caef6cafce281579da2cbfc	2018-03-14 04:36:52 -07:00
Tomer Shalev	c75adb0671	solves the Android pixel bug Summary: emilsjolander hi, this PR solves the following common and probable layout pixel scenario: the older code is presented for reference: ```java view.measure( View.MeasureSpec.makeMeasureSpec( Math.round(node.getLayoutWidth()), View.MeasureSpec.EXACTLY), View.MeasureSpec.makeMeasureSpec( Math.round(node.getLayoutHeight()), View.MeasureSpec.EXACTLY)); view.layout( Math.round(xOffset + node.getLayoutX()), Math.round(yOffset + node.getLayoutY()), Math.round(xOffset + node.getLayoutX() + node.getLayoutWidth()), Math.round(yOffset + node.getLayoutY() + node.getLayoutHeight())); ``` suppose now the following: - `xOffset + node.getLayoutX() = 2.2` - `node.getLayoutWidth() = 0.4` ==> `Math.round(node.getLayoutWidth()) = 0` - `Math.round(xOffset + node.getLayoutX() + node.getLayoutWidth()) = Math.round(2.2 + 0.4) = 3` this induces, the following measurements: ```java view.measure( View.MeasureSpec.makeMeasureSpec( 0, View.MeasureSpec.EXACTLY), View.MeasureSpec.makeMeasureSpec( Math.round(node.getLayoutHeight()), View.MeasureSpec.EXACTLY)); view.layout( 2, Math.round(yOffset + node.getLayoutY()), 3, Math.round(yOffset + node.getLayoutY() + node.getLayoutHeight())); ``` the width measurement of the view is 0, while the layout is `(3 - 2 = 1)`. my proposed solution is to measure the view the way it is now, but when layouting I use the `#getMeasuredWidth/Height()` methods, this will stop this problem from happening. I also want to note that this bug happens with high probability. Closes https://github.com/facebook/yoga/pull/712 Reviewed By: emilsjolander Differential Revision: D7231798 Pulled By: priteshrnandgaonkar fbshipit-source-id: 171da519639dbecd75416a574bccc4456aa22f31	2018-03-13 03:13:00 -07:00
Héctor Ramos	178b8f5f64	Update config files to use LICENSE-examples Summary: Use examples license in config files. Reviewed By: sophiebits Differential Revision: D7174444 fbshipit-source-id: 50c2369b18abd9d7fff9b4a66788fd67a5b40a0c	2018-03-08 10:21:51 -08:00