react-native 0.84.0-nightly-20251215-07bd24ed0 → 0.84.0-nightly-20251216-c16eb23a1

package/Libraries/Core/ReactNativeVersion.js

@@ -29,7 +29,7 @@ export default class ReactNativeVersion {
   static major: number = 0;
   static minor: number = 84;
   static patch: number = 0;
-  static prerelease: string | null = 'nightly-20251215-07bd24ed0';
+  static prerelease: string | null = 'nightly-20251216-c16eb23a1';
 
   static getVersionString(): string {
     return `${this.major}.${this.minor}.${this.patch}${this.prerelease != null ? `-${this.prerelease}` : ''}`;

package/React/Base/RCTVersion.m

@@ -24,7 +24,7 @@ NSDictionary* RCTGetReactNativeVersion(void)
                   RCTVersionMajor: @(0),
                   RCTVersionMinor: @(84),
                   RCTVersionPatch: @(0),
-                  RCTVersionPrerelease: @"nightly-20251215-07bd24ed0",
+                  RCTVersionPrerelease: @"nightly-20251216-c16eb23a1",
                   };
   });
   return __rnVersion;

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.84.0-nightly-20251215-07bd24ed0
+VERSION_NAME=0.84.0-nightly-20251216-c16eb23a1
 react.internal.publishingGroup=com.facebook.react
 react.internal.hermesPublishingGroup=com.facebook.hermes
 

package/ReactAndroid/hermes-engine/build.gradle.kts

@@ -11,7 +11,6 @@ import de.undercouch.gradle.tasks.download.Download
 import org.apache.tools.ant.taskdefs.condition.Os
 
 plugins {
-  id("maven-publish")
   id("signing")
   alias(libs.plugins.android.library)
   alias(libs.plugins.download)
@@ -348,10 +347,7 @@ android {
     java.srcDirs("$hermesDir/lib/Platform/Intl/java", "$hermesDir/lib/Platform/Unicode/java")
   }
 
-  buildFeatures {
-    prefab = true
-    prefabPublishing = true
-  }
+  buildFeatures { prefab = true }
 
   dependencies {
     implementation(libs.fbjni)
@@ -365,13 +361,6 @@ android {
     jniLibs.excludes.add("**/libfbjni.so")
   }
 
-  publishing {
-    multipleVariants {
-      withSourcesJar()
-      allVariants()
-    }
-  }
-
   prefab { create("hermesvm") { headers = prefabHeadersDir.absolutePath } }
 }
 

package/ReactAndroid/src/main/java/com/facebook/react/modules/systeminfo/ReactNativeVersion.kt

@@ -15,6 +15,6 @@ public object ReactNativeVersion {
     "major" to 0,
     "minor" to 84,
     "patch" to 0,
-    "prerelease" to "nightly-20251215-07bd24ed0"
+    "prerelease" to "nightly-20251216-c16eb23a1"
   )
 }

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -22,7 +22,7 @@ constexpr struct {
   int32_t Major = 0;
   int32_t Minor = 84;
   int32_t Patch = 0;
-  std::string_view Prerelease = "nightly-20251215-07bd24ed0";
+  std::string_view Prerelease = "nightly-20251216-c16eb23a1";
 } ReactNativeVersion;
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/animationbackend/AnimatedPropSerializer.cpp

@@ -149,6 +149,9 @@ void packAnimatedProp(
     case WIDTH:
     case HEIGHT:
     case FLEX:
+    case PADDING:
+    case MARGIN:
+    case POSITION:
       throw std::runtime_error("Tried to synchronously update layout props");
   }
 }

package/ReactCommon/react/renderer/animationbackend/AnimatedProps.h

@@ -17,6 +17,9 @@ enum PropName {
   WIDTH,
   HEIGHT,
   BORDER_RADII,
+  MARGIN,
+  PADDING,
+  POSITION,
   FLEX,
   TRANSFORM,
   BACKGROUND_COLOR,
@@ -75,6 +78,102 @@ inline void cloneProp(BaseViewProps &viewProps, const AnimatedPropBase &animated
       viewProps.borderRadii = get<CascadedBorderRadii>(animatedProp);
       break;
 
+    case MARGIN: {
+      const auto &margins = get<CascadedRectangleEdges<yoga::StyleLength>>(animatedProp);
+      if (margins.left.has_value()) {
+        viewProps.yogaStyle.setMargin(yoga::Edge::Left, margins.left.value());
+      }
+      if (margins.top.has_value()) {
+        viewProps.yogaStyle.setMargin(yoga::Edge::Top, margins.top.value());
+      }
+      if (margins.right.has_value()) {
+        viewProps.yogaStyle.setMargin(yoga::Edge::Right, margins.right.value());
+      }
+      if (margins.bottom.has_value()) {
+        viewProps.yogaStyle.setMargin(yoga::Edge::Bottom, margins.bottom.value());
+      }
+      if (margins.start.has_value()) {
+        viewProps.yogaStyle.setMargin(yoga::Edge::Start, margins.start.value());
+      }
+      if (margins.end.has_value()) {
+        viewProps.yogaStyle.setMargin(yoga::Edge::End, margins.end.value());
+      }
+      if (margins.horizontal.has_value()) {
+        viewProps.yogaStyle.setMargin(yoga::Edge::Horizontal, margins.horizontal.value());
+      }
+      if (margins.vertical.has_value()) {
+        viewProps.yogaStyle.setMargin(yoga::Edge::Vertical, margins.vertical.value());
+      }
+      if (margins.all.has_value()) {
+        viewProps.yogaStyle.setMargin(yoga::Edge::All, margins.all.value());
+      }
+      break;
+    }
+
+    case PADDING: {
+      const auto &paddings = get<CascadedRectangleEdges<yoga::StyleLength>>(animatedProp);
+      if (paddings.left.has_value()) {
+        viewProps.yogaStyle.setPadding(yoga::Edge::Left, paddings.left.value());
+      }
+      if (paddings.top.has_value()) {
+        viewProps.yogaStyle.setPadding(yoga::Edge::Top, paddings.top.value());
+      }
+      if (paddings.right.has_value()) {
+        viewProps.yogaStyle.setPadding(yoga::Edge::Right, paddings.right.value());
+      }
+      if (paddings.bottom.has_value()) {
+        viewProps.yogaStyle.setPadding(yoga::Edge::Bottom, paddings.bottom.value());
+      }
+      if (paddings.start.has_value()) {
+        viewProps.yogaStyle.setPadding(yoga::Edge::Start, paddings.start.value());
+      }
+      if (paddings.end.has_value()) {
+        viewProps.yogaStyle.setPadding(yoga::Edge::End, paddings.end.value());
+      }
+      if (paddings.horizontal.has_value()) {
+        viewProps.yogaStyle.setPadding(yoga::Edge::Horizontal, paddings.horizontal.value());
+      }
+      if (paddings.vertical.has_value()) {
+        viewProps.yogaStyle.setPadding(yoga::Edge::Vertical, paddings.vertical.value());
+      }
+      if (paddings.all.has_value()) {
+        viewProps.yogaStyle.setPadding(yoga::Edge::All, paddings.all.value());
+      }
+      break;
+    }
+
+    case POSITION: {
+      const auto &positions = get<CascadedRectangleEdges<yoga::StyleLength>>(animatedProp);
+      if (positions.left.has_value()) {
+        viewProps.yogaStyle.setPosition(yoga::Edge::Left, positions.left.value());
+      }
+      if (positions.top.has_value()) {
+        viewProps.yogaStyle.setPosition(yoga::Edge::Top, positions.top.value());
+      }
+      if (positions.right.has_value()) {
+        viewProps.yogaStyle.setPosition(yoga::Edge::Right, positions.right.value());
+      }
+      if (positions.bottom.has_value()) {
+        viewProps.yogaStyle.setPosition(yoga::Edge::Bottom, positions.bottom.value());
+      }
+      if (positions.start.has_value()) {
+        viewProps.yogaStyle.setPosition(yoga::Edge::Start, positions.start.value());
+      }
+      if (positions.end.has_value()) {
+        viewProps.yogaStyle.setPosition(yoga::Edge::End, positions.end.value());
+      }
+      if (positions.horizontal.has_value()) {
+        viewProps.yogaStyle.setPosition(yoga::Edge::Horizontal, positions.horizontal.value());
+      }
+      if (positions.vertical.has_value()) {
+        viewProps.yogaStyle.setPosition(yoga::Edge::Vertical, positions.vertical.value());
+      }
+      if (positions.all.has_value()) {
+        viewProps.yogaStyle.setPosition(yoga::Edge::All, positions.all.value());
+      }
+      break;
+    }
+
     case FLEX:
       viewProps.yogaStyle.setFlex(get<yoga::FloatOptional>(animatedProp));
       break;

package/ReactCommon/react/renderer/animationbackend/AnimatedPropsBuilder.h

@@ -31,6 +31,18 @@ struct AnimatedPropsBuilder {
   {
     props.push_back(std::make_unique<AnimatedProp<CascadedBorderRadii>>(BORDER_RADII, value));
   }
+  void setMargin(CascadedRectangleEdges<yoga::StyleLength> &value)
+  {
+    props.push_back(std::make_unique<AnimatedProp<CascadedRectangleEdges<yoga::StyleLength>>>(MARGIN, value));
+  }
+  void setPadding(CascadedRectangleEdges<yoga::StyleLength> &value)
+  {
+    props.push_back(std::make_unique<AnimatedProp<CascadedRectangleEdges<yoga::StyleLength>>>(PADDING, value));
+  }
+  void setPosition(CascadedRectangleEdges<yoga::StyleLength> &value)
+  {
+    props.push_back(std::make_unique<AnimatedProp<CascadedRectangleEdges<yoga::StyleLength>>>(POSITION, value));
+  }
   void setTransform(Transform &t)
   {
     props.push_back(std::make_unique<AnimatedProp<Transform>>(TRANSFORM, std::move(t)));

package/ReactCommon/react/renderer/animationbackend/AnimatedPropsRegistry.h

@@ -93,6 +93,40 @@ inline void updateProp(const PropName propName, BaseViewProps &viewProps, const
     case SHADOW_RADIUS:
       viewProps.shadowRadius = snapshot.props.shadowRadius;
       break;
+
+    case MARGIN:
+      viewProps.yogaStyle.setMargin(yoga::Edge::Left, snapshot.props.yogaStyle.margin(yoga::Edge::Left));
+      viewProps.yogaStyle.setMargin(yoga::Edge::Right, snapshot.props.yogaStyle.margin(yoga::Edge::Right));
+      viewProps.yogaStyle.setMargin(yoga::Edge::Top, snapshot.props.yogaStyle.margin(yoga::Edge::Top));
+      viewProps.yogaStyle.setMargin(yoga::Edge::Bottom, snapshot.props.yogaStyle.margin(yoga::Edge::Bottom));
+      viewProps.yogaStyle.setMargin(yoga::Edge::Start, snapshot.props.yogaStyle.margin(yoga::Edge::Start));
+      viewProps.yogaStyle.setMargin(yoga::Edge::End, snapshot.props.yogaStyle.margin(yoga::Edge::End));
+      viewProps.yogaStyle.setMargin(yoga::Edge::Horizontal, snapshot.props.yogaStyle.margin(yoga::Edge::Horizontal));
+      viewProps.yogaStyle.setMargin(yoga::Edge::Vertical, snapshot.props.yogaStyle.margin(yoga::Edge::Vertical));
+      break;
+
+    case PADDING:
+      viewProps.yogaStyle.setPadding(yoga::Edge::Left, snapshot.props.yogaStyle.padding(yoga::Edge::Left));
+      viewProps.yogaStyle.setPadding(yoga::Edge::Right, snapshot.props.yogaStyle.padding(yoga::Edge::Right));
+      viewProps.yogaStyle.setPadding(yoga::Edge::Top, snapshot.props.yogaStyle.padding(yoga::Edge::Top));
+      viewProps.yogaStyle.setPadding(yoga::Edge::Bottom, snapshot.props.yogaStyle.padding(yoga::Edge::Bottom));
+      viewProps.yogaStyle.setPadding(yoga::Edge::Start, snapshot.props.yogaStyle.padding(yoga::Edge::Start));
+      viewProps.yogaStyle.setPadding(yoga::Edge::End, snapshot.props.yogaStyle.padding(yoga::Edge::End));
+      viewProps.yogaStyle.setPadding(yoga::Edge::Horizontal, snapshot.props.yogaStyle.padding(yoga::Edge::Horizontal));
+      viewProps.yogaStyle.setPadding(yoga::Edge::Vertical, snapshot.props.yogaStyle.padding(yoga::Edge::Vertical));
+      break;
+
+    case POSITION:
+      viewProps.yogaStyle.setPosition(yoga::Edge::Left, snapshot.props.yogaStyle.position(yoga::Edge::Left));
+      viewProps.yogaStyle.setPosition(yoga::Edge::Right, snapshot.props.yogaStyle.position(yoga::Edge::Right));
+      viewProps.yogaStyle.setPosition(yoga::Edge::Top, snapshot.props.yogaStyle.position(yoga::Edge::Top));
+      viewProps.yogaStyle.setPosition(yoga::Edge::Bottom, snapshot.props.yogaStyle.position(yoga::Edge::Bottom));
+      viewProps.yogaStyle.setPosition(yoga::Edge::Start, snapshot.props.yogaStyle.position(yoga::Edge::Start));
+      viewProps.yogaStyle.setPosition(yoga::Edge::End, snapshot.props.yogaStyle.position(yoga::Edge::End));
+      viewProps.yogaStyle.setPosition(
+          yoga::Edge::Horizontal, snapshot.props.yogaStyle.position(yoga::Edge::Horizontal));
+      viewProps.yogaStyle.setPosition(yoga::Edge::Vertical, snapshot.props.yogaStyle.position(yoga::Edge::Vertical));
+      break;
   }
 }
 

package/ReactCommon/react/renderer/animationbackend/AnimationBackend.cpp

@@ -54,7 +54,9 @@ static inline bool mutationHasLayoutUpdates(
   for (auto& animatedProp : mutation.props.props) {
     // TODO: there should also be a check for the dynamic part
     if (animatedProp->propName == WIDTH || animatedProp->propName == HEIGHT ||
-        animatedProp->propName == FLEX) {
+        animatedProp->propName == FLEX || animatedProp->propName == MARGIN ||
+        animatedProp->propName == PADDING ||
+        animatedProp->propName == POSITION) {
       return true;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native",
-  "version": "0.84.0-nightly-20251215-07bd24ed0",
+  "version": "0.84.0-nightly-20251216-c16eb23a1",
   "description": "A framework for building native apps using React",
   "license": "MIT",
   "repository": {
@@ -160,13 +160,13 @@
   },
   "dependencies": {
     "@jest/create-cache-key-function": "^29.7.0",
-    "@react-native/assets-registry": "0.84.0-nightly-20251215-07bd24ed0",
-    "@react-native/codegen": "0.84.0-nightly-20251215-07bd24ed0",
-    "@react-native/community-cli-plugin": "0.84.0-nightly-20251215-07bd24ed0",
-    "@react-native/gradle-plugin": "0.84.0-nightly-20251215-07bd24ed0",
-    "@react-native/js-polyfills": "0.84.0-nightly-20251215-07bd24ed0",
-    "@react-native/normalize-colors": "0.84.0-nightly-20251215-07bd24ed0",
-    "@react-native/virtualized-lists": "0.84.0-nightly-20251215-07bd24ed0",
+    "@react-native/assets-registry": "0.84.0-nightly-20251216-c16eb23a1",
+    "@react-native/codegen": "0.84.0-nightly-20251216-c16eb23a1",
+    "@react-native/community-cli-plugin": "0.84.0-nightly-20251216-c16eb23a1",
+    "@react-native/gradle-plugin": "0.84.0-nightly-20251216-c16eb23a1",
+    "@react-native/js-polyfills": "0.84.0-nightly-20251216-c16eb23a1",
+    "@react-native/normalize-colors": "0.84.0-nightly-20251216-c16eb23a1",
+    "@react-native/virtualized-lists": "0.84.0-nightly-20251216-c16eb23a1",
     "abort-controller": "^3.0.0",
     "anser": "^1.4.9",
     "ansi-regex": "^5.0.0",

package/sdks/hermes-engine/hermes-engine.podspec

@@ -28,6 +28,14 @@ else
   version = versionProperties['HERMES_VERSION_NAME']
 end
 
+# Local monorepo build
+if package['version'] == "1000.0.0" then
+  hermesCompilerVersion = package['dependencies']['hermes-compiler']
+  if hermesCompilerVersion != "0.0.0" then
+    version = hermesCompilerVersion
+  end
+end
+
 source_type = hermes_source_type(version, react_native_path)
 source = podspec_source(source_type, version, react_native_path)