expo-modules-core 57.0.14 → 57.0.16

package/CHANGELOG.md

@@ -10,6 +10,22 @@
 
 ### 💡 Others
 
+## 57.0.16 — 2026-09-04
+
+_This version does not introduce any user-facing changes._
+
+## 57.0.15 — 2026-09-01
+
+### 🐛 Bug fixes
+
+- [iOS][Android] Fixed a `matchContents` `RNHostView` and the `matchContents` host around it feeding each other's size back and forth, which grew the layout on every pass. ([#49483](https://github.com/expo/expo/pull/49483) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
+- [iOS] Fixed SwiftUI view props re-decoding every field on every props update. Fabric sends the whole props map rather than a delta, so an unrelated prop change replaced each decoded value with an equal but distinct one, which cost a decode per field and stopped SwiftUI from pruning the view tree that reads it. A field whose raw value is unchanged now keeps the value decoded before, the same way `ExpoFabricView.updateProps` already worked for UIKit views. ([#48426](https://github.com/expo/expo/pull/48426) by [@nishan](https://github.com/intergalacticspacehighway))
+
+### 💡 Others
+
+- Migrated from deprecated react-native-worklets WorkletRuntime API `executeSync` to up-to-date `runSync`. `runSync` is available since 0.7.0. ([#48691](https://github.com/expo/expo/pull/48691) by [@tjzel](https://github.com/tjzel))
+- Added internal `ExpoModulesProviderModuleName` lookup key for `ExpoModulesProvider` class. ([#49539](https://github.com/expo/expo/pull/49539) by [@kudo](https://github.com/kudo))
+
 ## 57.0.14 — 2026-08-26
 
 ### 🎉 New features

package/android/build.gradle

@@ -27,7 +27,7 @@ if (shouldIncludeCompose) {
 }
 
 group = 'host.exp.exponent'
-version = '57.0.14'
+version = '57.0.16'
 
 def isExpoModulesCoreTests = {
   Gradle gradle = getGradle()
@@ -94,7 +94,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "57.0.14"
+    versionName "57.0.16"
     buildConfigField "String", "EXPO_MODULES_CORE_VERSION", "\"${versionName}\""
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", "true"
 

package/android/src/main/cpp/worklets/WorkletJSCallInvoker.cpp

@@ -24,10 +24,7 @@ namespace expo {
       return;
     }
 
-    workletRuntime->executeSync([func = std::move(func)](jsi::Runtime &rt) -> jsi::Value {
-      func(rt);
-      return jsi::Value::undefined();
-    });
+    workletRuntime->runSync(func);
   }
 } // namespace expo
 

package/common/cpp/fabric/ExpoViewComponentDescriptor.h

@@ -30,6 +30,32 @@ public:
     return std::static_pointer_cast<std::string const>(this->flavor_)->c_str();
   }
 
+  static bool isRNHostView(const react::Props::Shared &props) {
+    // Currently, only RNHostView can have `sizesToContent` set to true.
+    return ShadowNodeType::sizesToContent(props);
+  }
+
+  std::shared_ptr<facebook::react::ShadowNode> createShadowNode(
+    const facebook::react::ShadowNodeFragment &fragment,
+    const facebook::react::ShadowNodeFamily::Shared &family
+  ) const override {
+    if (!isRNHostView(fragment.props)) {
+      return facebook::react::ConcreteComponentDescriptor<ShadowNodeType>::createShadowNode(
+        fragment, family);
+    }
+
+    // Treat RNHostView as a leaf node and measurable node in Yoga, so that it can be measured by its children.
+    auto traits = this->getTraits();
+    traits.set(facebook::react::ShadowNodeTraits::Trait::LeafYogaNode);
+    traits.set(facebook::react::ShadowNodeTraits::Trait::MeasurableYogaNode);
+
+    auto shadowNode = std::make_shared<ShadowNodeType>(fragment, family, traits);
+
+    this->adopt(*shadowNode);
+
+    return shadowNode;
+  }
+
   void adopt(facebook::react::ShadowNode &shadowNode) const override {
     react_native_assert(dynamic_cast<ShadowNodeType *>(&shadowNode));
 
@@ -81,6 +107,21 @@ public:
       // Updates yoga style from props and sets the node dirty
       snode->updateYogaProps();
     }
+
+    if (isRNHostView(snode->getProps())) {
+      auto const &props = *std::static_pointer_cast<const facebook::react::ViewProps>(
+        snode->getProps());
+      auto &style = const_cast<facebook::yoga::Style &>(props.yogaStyle);
+
+      // If RNHostView has align self set to auto or stretch, we should override it to flex-start so that the node can size itself to its content
+      auto const alignSelf = style.alignSelf();
+
+      if (alignSelf == facebook::yoga::Align::Auto || alignSelf == facebook::yoga::Align::Stretch) {
+        style.setAlignSelf(facebook::yoga::Align::FlexStart);
+        snode->updateYogaProps();
+      }
+    }
+
     facebook::react::ConcreteComponentDescriptor<ShadowNodeType>::adopt(shadowNode);
   }
 };

package/common/cpp/fabric/ExpoViewShadowNode.h

@@ -5,6 +5,11 @@
 #ifdef __cplusplus
 
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/core/LayoutableShadowNode.h>
+
+#include <algorithm>
 
 #include "ContentOriginRegistry.h"
 #include "ExpoViewEventEmitter.h"
@@ -77,7 +82,112 @@ public:
     return {.x = contentOrigin->x - ownOrigin.x, .y = contentOrigin->y - ownOrigin.y};
   }
 
+  // Currently, only `RNHostView` declares `expoInternalSizeFromChildren`
+  static bool sizesToContent(const react::Props::Shared &props) {
+    auto const *viewProps = dynamic_cast<const ExpoViewProps *>(props.get());
+
+    if (viewProps == nullptr) {
+      return false;
+    }
+
+    auto const it = viewProps->propsMap.find("expoInternalSizeFromChildren");
+    return it != viewProps->propsMap.end() && it->second.isBool() && it->second.getBool();
+  }
+
+  // Yoga calls this method for RNHostView when it has matchContents set
+  react::Size measureContent(
+    const react::LayoutContext &layoutContext,
+    const react::LayoutConstraints &layoutConstraints
+  ) const override {
+    // Return default behavior when RNHostView does not have `sizesToContent` set to true
+    if (!sizesToContent(this->getProps())) {
+      return ConcreteViewShadowNode::measureContent(layoutContext, layoutConstraints);
+    }
+
+    auto const *content = hostedContent();
+
+    if (content == nullptr) {
+      return {};
+    }
+
+    return content->measure(layoutContext, hostedContentConstraints(*content));
+  }
+
+  // We override this so RNHostView can lay out it's children
+  // We marked it as a Leaf node so we need to manually lay out the hosted content
+  void layout(react::LayoutContext layoutContext) override {
+    ConcreteViewShadowNode::layout(layoutContext);
+
+    if (!sizesToContent(this->getProps())) {
+      return;
+    }
+
+    auto const *content = hostedContent();
+
+    if (content == nullptr) {
+      return;
+    }
+
+    // Use the same constraint that was used to measure the content, so that the layout is consistent with the measurement
+    auto const clonedContent = content->clone({});
+    static_cast<react::LayoutableShadowNode &>(*clonedContent).layoutTree(
+      layoutContext,
+      hostedContentConstraints(*content)
+    );
+
+    this->replaceChild(*content, clonedContent, 0);
+
+    if (layoutContext.affectedNodes != nullptr) {
+      layoutContext.affectedNodes->push_back(
+        static_cast<const react::LayoutableShadowNode *>(clonedContent.get()));
+    }
+  }
+
 private:
+  const react::LayoutableShadowNode *hostedContent() const {
+    auto const &children = this->getChildren();
+
+    return children.empty()
+      ? nullptr
+      : dynamic_cast<const react::LayoutableShadowNode *>(children.front().get());
+  }
+
+  react::LayoutDirection resolvedLayoutDirection() const {
+    return YGNodeLayoutGetDirection(&this->yogaNode_) == YGDirectionRTL
+      ? react::LayoutDirection::RightToLeft
+      : react::LayoutDirection::LeftToRight;
+  }
+
+  react::LayoutConstraints hostedContentConstraints(const react::ShadowNode &content) const {
+    react::LayoutConstraints constraints{};
+    constraints.layoutDirection = resolvedLayoutDirection();
+
+    auto const *contentProps = dynamic_cast<const react::ViewProps *>(content.getProps().get());
+
+    if (contentProps == nullptr) {
+      return constraints;
+    }
+
+    auto const &style = contentProps->yogaStyle;
+
+    constrainToPoints(style.minDimension(facebook::yoga::Dimension::Width),
+                      constraints.minimumSize.width);
+    constrainToPoints(style.minDimension(facebook::yoga::Dimension::Height),
+                      constraints.minimumSize.height);
+    constrainToPoints(style.maxDimension(facebook::yoga::Dimension::Width),
+                      constraints.maximumSize.width);
+    constrainToPoints(style.maxDimension(facebook::yoga::Dimension::Height),
+                      constraints.maximumSize.height);
+
+    return constraints;
+  }
+
+  static void constrainToPoints(facebook::yoga::StyleSizeLength length, react::Float &constraint) {
+    if (length.isPoints() && length.value().isDefined()) {
+      constraint = std::max<react::Float>(0, length.value().unwrap());
+    }
+  }
+
   void initialize() noexcept {
     auto &viewProps = static_cast<const ExpoViewProps &>(*this->props_);
 

package/ios/Core/AppContext.swift

@@ -724,12 +724,14 @@ public final class AppContext: NSObject, EXAppContextProtocol, @unchecked Sendab
    */
   @objc
   public static func modulesProvider(withName providerName: String = "ExpoModulesProvider") -> ModulesProvider {
-    // [0] When ExpoModulesCore is built as separated framework/module,
-    // we should explicitly load main bundle's `ExpoModulesProvider` class.
-    // CFBundleExecutable is tried first: it is the product name, from which the Swift module
-    // name is derived. CFBundleName is kept as a fallback for the uncommon case where both
-    // values are identical valid identifiers.
+    // [0] When ExpoModulesCore is built as a separate framework/module,
+    // explicitly load the main bundle's `ExpoModulesProvider` class.
+    // `ExpoModulesProviderModuleName` is an internal key that allows repack-app to
+    // preserve the original Swift module name. Try `CFBundleExecutable` next because
+    // it usually matches the Swift module name. Keep `CFBundleName` as a final fallback
+    // for cases where it is also a valid module identifier.
     let mainBundleNames = [
+      Bundle.main.infoDictionary?["ExpoModulesProviderModuleName"],
       Bundle.main.infoDictionary?["CFBundleExecutable"],
       Bundle.main.infoDictionary?["CFBundleName"]
     ].compactMap { $0 as? String }

package/ios/Core/Conversions.swift

@@ -34,6 +34,23 @@ public struct Conversions {
     }
   }
 
+  /**
+   Compares two prop values for equality, to tell an actual prop change from a re-delivery of the
+   same value.
+   */
+  static func areValuesEqual(_ lhs: Any?, _ rhs: Any?) -> Bool {
+    switch (lhs, rhs) {
+    case (nil, nil):
+      return true
+    case let (lhsValue as AnyHashable, rhsValue as AnyHashable):
+      return lhsValue == rhsValue
+    case let (lhsValue as NSObjectProtocol, rhsValue as NSObjectProtocol):
+      return lhsValue.isEqual(rhsValue)
+    default:
+      return false
+    }
+  }
+
   static func fromNSObject(_ object: Any) -> Any {
     switch object {
     case let object as NSArray:

package/ios/Core/Views/SwiftUI/SwiftUIViewProps.swift

@@ -47,9 +47,31 @@ extension ExpoSwiftUI {
      */
     public let globalEventDispatcher = EventDispatcher(GLOBAL_EVENT_NAME)
 
+    /**
+     A dictionary to store previous raw prop values for change detection.
+     */
+    private var previousRawProps: [String: Any] = [:]
+
     internal func updateRawProps(_ rawProps: [String: Any], appContext: AppContext) throws {
-      // Update the props just like the records
-      try update(withDict: rawProps, appContext: appContext)
+      try fieldsOf(self).forEach { field in
+        guard let key = field.key else {
+          return
+        }
+        guard rawProps.keys.contains(key) else {
+          if field.isRequired {
+            try field.set(nil, appContext: appContext)
+          }
+          return
+        }
+        let newValue = rawProps[key]
+        let previousValue = previousRawProps[key]
+
+        if !Conversions.areValuesEqual(previousValue, newValue) {
+          try field.set(newValue, appContext: appContext)
+
+          previousRawProps[key] = newValue
+        }
+      }
 
       // Notify subscribed views about the change to re-render them.
       objectWillChange.send()

package/ios/Fabric/ExpoFabricView.swift

@@ -91,7 +91,7 @@ open class ExpoFabricView: ExpoFabricViewObjC, AnyExpoView {
       let previousValue = previousProps[key]
 
       // only set the prop if the value has changed
-      if !areValuesEqual(previousValue, convertedNewValue) {
+      if !Conversions.areValuesEqual(previousValue, convertedNewValue) {
         // TODO: @tsapeta: Figure out better way to rethrow errors from here.
         // Adding `throws` keyword to the function results in different
         // method signature in Objective-C. Maybe just call `RCTLogError`?
@@ -102,21 +102,6 @@ open class ExpoFabricView: ExpoFabricViewObjC, AnyExpoView {
     }
   }
 
-  /**
-   Helper function to compare two values for equality using string representation.
-   */
-  private func areValuesEqual(_ lhs: Any?, _ rhs: Any?) -> Bool {
-    switch (lhs, rhs) {
-    case (nil, nil):
-      return true
-    case let (lhsValue as AnyHashable, rhsValue as AnyHashable):
-      return lhsValue == rhsValue
-    case let (lhsValue as NSObjectProtocol, rhsValue as NSObjectProtocol):
-      return lhsValue.isEqual(rhsValue)
-    default:
-      return false
-    }
-  }
   /**
    Calls lifecycle methods registered by `OnViewDidUpdateProps` definition component.
    */

package/ios/WorkletsAdapter/ExpoWorkletsBridgeProvider.mm

@@ -233,7 +233,7 @@ static jsi::Value callWorklet(jsi::Runtime &rt, std::shared_ptr<worklets::Serial
     return;
   }
 
-  workletRuntime->executeSync([worklet, arguments](jsi::Runtime &rt) -> jsi::Value {
+  workletRuntime->runSync([worklet, arguments](jsi::Runtime &rt) -> jsi::Value {
     return callWorklet(rt, worklet, arguments);
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "57.0.14",
+  "version": "57.0.16",
   "description": "The core of Expo Modules architecture",
   "main": "src/index.ts",
   "types": "build/index.d.ts",
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "@expo/expo-modules-macros-plugin": "0.6.1",
-    "expo-modules-jsi": "~57.0.6",
+    "expo-modules-jsi": "~57.0.8",
     "invariant": "^2.2.4"
   },
   "peerDependencies": {
@@ -66,7 +66,7 @@
     "@types/invariant": "^2.2.33",
     "expo-module-scripts": "56.0.3"
   },
-  "gitHead": "c300d2cc60c9e684e64f48d9bc90ea18a571d01d",
+  "gitHead": "d36f125067e9c6e67689f2b75cf4fb19254c3c59",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",