expo-modules-core 57.0.3 → 57.0.5

package/CHANGELOG.md

@@ -10,6 +10,25 @@
 
 ### 💡 Others
 
+## 57.0.5 — 2026-07-15
+
+_This version does not introduce any user-facing changes._
+
+## 57.0.4 — 2026-07-15
+
+### 🎉 New features
+
+- [iOS] `@SharedObject` now binds `@JS` methods, properties and the `@JS init` directly onto the class prototype, so they no longer need `Function(…)` / `Property(…)` / `Constructor { … }` definition entries. ([#47107](https://github.com/expo/expo/pull/47107) by [@tsapeta](https://github.com/tsapeta))
+
+### 🐛 Bug fixes
+
+- [iOS] Fixed a crash when the runtime is reloaded while async function calls are still suspended in their native body. Concurrent functions now decode `this` and the arguments buffer synchronously inside the host call and schedule only converted native values, so no JSI-owned wrappers are destroyed off the JS thread after the runtime is torn down. ([#47716](https://github.com/expo/expo/issues/47716), [#47717](https://github.com/expo/expo/pull/47717) by [@AlirezaHadjar](https://github.com/AlirezaHadjar))
+- [Android] Support `android.graphics.Color` arguments and props on Android below API 26 by adding a `ColorCompat` wrapper, since the class-based `Color` API (`Color.valueOf` and the float accessors) only exists on API 26 and above. ([#47546](https://github.com/expo/expo/issues/47546) by [@anasvemmully](https://github.com/anasvemmully)) ([#47575](https://github.com/expo/expo/pull/47575) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
+- [iOS] Fix a `SIGABRT` crash when unmounting a SwiftUI view tree that still holds a focused field nested inside a container (e.g. an `@expo/ui` `TextField` inside an `HStack` or `LabeledContent` in a `Form`), such as dismissing a modal from a native header button. Resigning the first responder on unmount now recurses through the removed subtree instead of only handling a top-level focusable view. ([#47682](https://github.com/expo/expo/issues/47682) by [@andreavrr](https://github.com/andreavrr)) ([#47709](https://github.com/expo/expo/pull/47709) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
+- [iOS] Pair a native shared object with one JavaScript object per runtime, so a shared object exposed to several runtimes (e.g. the main and UI runtimes, or worklet contexts) keeps a live pairing in each instead of only the one paired last. ([#47238](https://github.com/expo/expo/pull/47238) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Fix `hsl()`/`hsla()` color strings failing to parse on some OS versions (observed on the iOS 27.0 beta), caused by regex-literal fragments composed in `RegexBuilder` blocks. The CSS color patterns are now built from `RegexBuilder` primitives only. ([#47543](https://github.com/expo/expo/pull/47543) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Fixed a potential use-after-free when native code scheduled work onto the JS thread (e.g. settling an async function's promise from a background queue) while the React instance was concurrently tearing down the runtime scheduler on reload. The dispatch trampoline now references the scheduler weakly and drops the task once the scheduler is gone. ([#47492](https://github.com/expo/expo/pull/47492) by [@tsapeta](https://github.com/tsapeta))
+
 ## 57.0.3 — 2026-07-07
 
 _This version does not introduce any user-facing changes._
@@ -37,7 +56,6 @@ _This version does not introduce any user-facing changes._
 
 ### 🐛 Bug fixes
 
-- [iOS] Pair a native shared object with one JavaScript object per runtime, so a shared object exposed to several runtimes (e.g. the main and UI runtimes, or worklet contexts) keeps a live pairing in each instead of only the one paired last. ([#47238](https://github.com/expo/expo/pull/47238) by [@tsapeta](https://github.com/tsapeta))
 - [Android][compose] Guard `onLayout` against detached window to prevent `LayoutNode should be attached to an owner` crash. ([#47085](https://github.com/expo/expo/pull/47085) by [@roitium](https://github.com/roitium))
 - [Android] Fix Jetpack Compose `Host` content disappearing before a react-native-screens pop animation finishes, by deferring composition disposal to window detach while the view is still on-screen for a transition. ([#45914](https://github.com/expo/expo/issues/45914), [#47086](https://github.com/expo/expo/issues/47086) by [@aubrey-wodonga](https://github.com/aubrey-wodonga)) ([#47099](https://github.com/expo/expo/pull/47099) by [@nishan](https://github.com/intergalacticspacehighway))
 - [iOS] Fix a crash on `Updates.reloadAsync()` where the previous `AppContext` could deallocate before the old runtime finished tearing down, releasing cached JSI objects against a dying runtime on the wrong thread. Its lifetime is now tied to the runtime via native state attached to the `global.expo` object. ([#47051](https://github.com/expo/expo/issues/47051) by [@HaiyiMei](https://github.com/HaiyiMei)) ([#47080](https://github.com/expo/expo/pull/47080), [#47098](https://github.com/expo/expo/pull/47098) by [@tsapeta](https://github.com/tsapeta))

package/ExpoModulesCore.podspec

@@ -127,14 +127,22 @@ Pod::Spec.new do |s|
   s.test_spec 'Tests' do |test_spec|
     test_spec.dependency 'ExpoModulesTestCore'
 
-    test_spec.source_files = 'ios/Tests/**/*.{m,swift}'
-
-    # The library's -lc++ lives in `user_target_xcconfig` (for consuming apps), which a
-    # test_spec target doesn't inherit. The test bundle links libExpoModulesCore.a (C++)
-    # but has no C++/Obj-C++ source of its own, so the linker driver is clang, not clang++,
-    # and libc++ isn't linked implicitly. Link it explicitly here.
+    test_spec.source_files = 'ios/Tests/**/*.{h,m,mm,swift}'
+
+    # The Obj-C++ tests include React renderer headers, which need the library's folly
+    # config. It reaches them through the library's `compiler_flags`, which test specs
+    # inherit and CocoaPods applies per-file to C-family sources.
+    #
+    # OTHER_LDFLAGS: the library's -lc++ lives in `user_target_xcconfig` (for consuming
+    # apps), which a test_spec target doesn't inherit. The test bundle links
+    # libExpoModulesCore.a (C++), so link libc++ explicitly.
+    #
+    # SWIFT_OBJC_BRIDGING_HEADER: a test target has no module for its own Obj-C sources,
+    # so the Swift tests see the Obj-C test doubles (`ios/Tests/Mocks`) through the
+    # bridging header.
     test_spec.pod_target_xcconfig = {
-      'OTHER_LDFLAGS' => '$(inherited) -lc++'
+      'OTHER_LDFLAGS' => '$(inherited) -lc++',
+      'SWIFT_OBJC_BRIDGING_HEADER' => '$(PODS_TARGET_SRCROOT)/ios/Tests/Tests-Bridging-Header.h'
     }
   end
 end

package/android/build.gradle

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

package/android/src/main/java/expo/modules/kotlin/types/ColorCompat.kt

@@ -0,0 +1,148 @@
+package expo.modules.kotlin.types
+
+import android.graphics.Color
+import android.os.Build
+import androidx.annotation.ColorInt
+import androidx.annotation.RequiresApi
+
+/**
+ * Compatibility wrapper for [Color] instance APIs added in API 26.
+ *
+ * Remove this class when expo-modules-core minSdkVersion is 26 or higher. Android Lint's
+ * ObsoleteSdkInt check should flag these version gates after that bump.
+ */
+class ColorCompat private constructor() {
+  companion object {
+    private val defaultLegacyColor = LegacyColor(
+      red = 0f,
+      green = 0f,
+      blue = 0f,
+      alpha = 1f,
+      argb = Color.BLACK
+    )
+
+    @JvmStatic
+    fun valueOf(@ColorInt color: Int): Color {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.valueOf(color)
+      }
+      return LegacyColor(
+        red = Color.red(color) / 255f,
+        green = Color.green(color) / 255f,
+        blue = Color.blue(color) / 255f,
+        alpha = Color.alpha(color) / 255f,
+        argb = color
+      )
+    }
+
+    @JvmStatic
+    fun valueOf(red: Float, green: Float, blue: Float, alpha: Float): Color {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.valueOf(red, green, blue, alpha)
+      }
+      val saturatedRed = red.coerceIn(0f, 1f)
+      val saturatedGreen = green.coerceIn(0f, 1f)
+      val saturatedBlue = blue.coerceIn(0f, 1f)
+      val saturatedAlpha = alpha.coerceIn(0f, 1f)
+      return LegacyColor(
+        red = saturatedRed,
+        green = saturatedGreen,
+        blue = saturatedBlue,
+        alpha = saturatedAlpha,
+        argb = Color.argb(
+          toColorComponent(saturatedAlpha),
+          toColorComponent(saturatedRed),
+          toColorComponent(saturatedGreen),
+          toColorComponent(saturatedBlue)
+        )
+      )
+    }
+
+    @JvmStatic
+    fun toArgb(color: Color): Int {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.toArgb(color)
+      }
+      return legacyColor(color).argb
+    }
+
+    @JvmStatic
+    fun alpha(color: Color): Float {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.alpha(color)
+      }
+      return legacyColor(color).alpha
+    }
+
+    @JvmStatic
+    fun red(color: Color): Float {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.red(color)
+      }
+      return legacyColor(color).red
+    }
+
+    @JvmStatic
+    fun green(color: Color): Float {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.green(color)
+      }
+      return legacyColor(color).green
+    }
+
+    @JvmStatic
+    fun blue(color: Color): Float {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        return Api26Impl.blue(color)
+      }
+      return legacyColor(color).blue
+    }
+
+    private fun legacyColor(color: Color): LegacyColor {
+      return color as? LegacyColor ?: defaultLegacyColor
+    }
+
+    private fun toColorComponent(component: Float): Int {
+      return (component * 255f + 0.5f).toInt()
+    }
+  }
+
+  private class LegacyColor(
+    val red: Float,
+    val green: Float,
+    val blue: Float,
+    val alpha: Float,
+    @ColorInt val argb: Int
+  ) : Color()
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private object Api26Impl {
+    fun valueOf(@ColorInt color: Int): Color {
+      return Color.valueOf(color)
+    }
+
+    fun valueOf(red: Float, green: Float, blue: Float, alpha: Float): Color {
+      return Color.valueOf(red, green, blue, alpha)
+    }
+
+    fun toArgb(color: Color): Int {
+      return color.toArgb()
+    }
+
+    fun alpha(color: Color): Float {
+      return color.alpha()
+    }
+
+    fun red(color: Color): Float {
+      return color.red()
+    }
+
+    fun green(color: Color): Float {
+      return color.green()
+    }
+
+    fun blue(color: Color): Float {
+      return color.blue()
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/types/ColorTypeConverter.kt

@@ -1,8 +1,6 @@
 package expo.modules.kotlin.types
 
 import android.graphics.Color
-import android.os.Build
-import androidx.annotation.RequiresApi
 import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.ReadableType
 import expo.modules.kotlin.AppContext
@@ -262,7 +260,7 @@ private fun hslToColor(h: Float, s: Float, l: Float, a: Float): Color {
     g = hueToRgb(p, q, hue)
     b = hueToRgb(p, q, hue - 1f / 3f)
   }
-  return Color.valueOf(r.coerceIn(0f, 1f), g.coerceIn(0f, 1f), b.coerceIn(0f, 1f), a)
+  return ColorCompat.valueOf(r.coerceIn(0f, 1f), g.coerceIn(0f, 1f), b.coerceIn(0f, 1f), a)
 }
 
 private fun hwbToColor(h: Float, w: Float, b: Float, a: Float): Color {
@@ -272,10 +270,10 @@ private fun hwbToColor(h: Float, w: Float, b: Float, a: Float): Color {
   val white = if (sum > 1f) ww / sum else ww
   val black = if (sum > 1f) bb / sum else bb
   val rgb = hslToColor(h, 1f, 0.5f, 1f)
-  val r = rgb.red() * (1f - white - black) + white
-  val g = rgb.green() * (1f - white - black) + white
-  val bl = rgb.blue() * (1f - white - black) + white
-  return Color.valueOf(r.coerceIn(0f, 1f), g.coerceIn(0f, 1f), bl.coerceIn(0f, 1f), a)
+  val r = ColorCompat.red(rgb) * (1f - white - black) + white
+  val g = ColorCompat.green(rgb) * (1f - white - black) + white
+  val bl = ColorCompat.blue(rgb) * (1f - white - black) + white
+  return ColorCompat.valueOf(r.coerceIn(0f, 1f), g.coerceIn(0f, 1f), bl.coerceIn(0f, 1f), a)
 }
 
 /**
@@ -292,7 +290,7 @@ private fun parseHexColor(value: String): Color? {
     val r = match.groupValues[1].repeat(2).toInt(16)
     val g = match.groupValues[2].repeat(2).toInt(16)
     val b = match.groupValues[3].repeat(2).toInt(16)
-    return Color.valueOf(r / 255f, g / 255f, b / 255f, 1f)
+    return ColorCompat.valueOf(r / 255f, g / 255f, b / 255f, 1f)
   }
 
   // #RGBA → #RRGGBBAA
@@ -301,7 +299,7 @@ private fun parseHexColor(value: String): Color? {
     val g = match.groupValues[2].repeat(2).toInt(16)
     val b = match.groupValues[3].repeat(2).toInt(16)
     val a = match.groupValues[4].repeat(2).toInt(16)
-    return Color.valueOf(r / 255f, g / 255f, b / 255f, a / 255f)
+    return ColorCompat.valueOf(r / 255f, g / 255f, b / 255f, a / 255f)
   }
 
   // #RRGGBBAA (CSS byte order: alpha is last, unlike Android's #AARRGGBB)
@@ -311,7 +309,7 @@ private fun parseHexColor(value: String): Color? {
     val g = ((hex shr 16) and 0xFF).toInt()
     val b = ((hex shr 8) and 0xFF).toInt()
     val a = (hex and 0xFF).toInt()
-    return Color.valueOf(r / 255f, g / 255f, b / 255f, a / 255f)
+    return ColorCompat.valueOf(r / 255f, g / 255f, b / 255f, a / 255f)
   }
 
   return null
@@ -329,7 +327,7 @@ private fun parseCssColorFunction(value: String): Color? {
     val g = parseRgbComponent(match.groupValues[2])
     val b = parseRgbComponent(match.groupValues[3])
     val a = parseAlpha(match.groupValues[4].ifEmpty { null })
-    return Color.valueOf(r, g, b, a)
+    return ColorCompat.valueOf(r, g, b, a)
   }
 
   // hsl/hsla
@@ -355,7 +353,6 @@ private fun parseCssColorFunction(value: String): Color? {
 
 // endregion
 
-@RequiresApi(Build.VERSION_CODES.O)
 class ColorTypeConverter : DynamicAwareTypeConverters<Color>() {
   override fun convertFromDynamic(value: Dynamic, context: AppContext?, forceConversion: Boolean): Color {
     return when (value.type) {
@@ -389,18 +386,18 @@ class ColorTypeConverter : DynamicAwareTypeConverters<Color>() {
       throw InvalidColorComponentsException(value.size)
     }
     val alpha = value.getOrNull(3) ?: 1.0
-    return Color.valueOf(value[0].toFloat(), value[1].toFloat(), value[2].toFloat(), alpha.toFloat())
+    return ColorCompat.valueOf(value[0].toFloat(), value[1].toFloat(), value[2].toFloat(), alpha.toFloat())
   }
 
   private fun colorFromInt(value: Int): Color {
-    return Color.valueOf(value)
+    return ColorCompat.valueOf(value)
   }
 
   private fun colorFromString(value: String): Color {
     val normalizedValue = value.trim().lowercase()
     val colorFromString = namedColors[normalizedValue]
     if (colorFromString != null) {
-      return Color.valueOf(
+      return ColorCompat.valueOf(
         colorFromString[0],
         colorFromString[1],
         colorFromString[2],
@@ -411,12 +408,12 @@ class ColorTypeConverter : DynamicAwareTypeConverters<Color>() {
     if (normalizedValue.startsWith('#')) {
       parseHexColor(normalizedValue)?.let { return it }
       // Fall through to toColorInt() for standard #RRGGBB / #AARRGGBB
-      return Color.valueOf(normalizedValue.toColorInt())
+      return ColorCompat.valueOf(normalizedValue.toColorInt())
     }
 
     parseCssColorFunction(normalizedValue)?.let { return it }
 
-    return Color.valueOf(normalizedValue.toColorInt())
+    return ColorCompat.valueOf(normalizedValue.toColorInt())
   }
 
   override fun getCppRequiredTypes(): ExpectedType =

package/android/src/main/java/expo/modules/kotlin/types/TypeConverterProvider.kt

@@ -275,6 +275,8 @@ object TypeConverterProviderImpl : TypeConverterProvider {
 
       Any::class.java to AnyTypeConverter(),
 
+      Color::class.java to ColorTypeConverter(),
+
       // Unit converter doesn't care about nullability.
       // It will always return Unit
       Unit::class.java to UnitTypeConverter(),
@@ -285,7 +287,6 @@ object TypeConverterProviderImpl : TypeConverterProvider {
     if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
       return converters + mapOf(
         Path::class.java to PathTypeConverter(),
-        Color::class.java to ColorTypeConverter(),
         LocalDate::class.java to DateTypeConverter()
       )
     }

package/ios/Core/AppContext.swift

@@ -436,6 +436,10 @@ public final class AppContext: NSObject, EXAppContextProtocol, @unchecked Sendab
    to a synchronous no-op scheduler — callers can detect this via
    `JavaScriptRuntime.supportsAsyncScheduling`.
 
+   `scheduler` is an opaque handle that `dispatch` understands; the factories pass
+   a handle created by `expo::createReactSchedulerHandle` that references the React
+   runtime scheduler weakly (see `EXReactSchedulerDispatch.h`).
+
    `dispatch` is a raw pointer to a C function with signature
    `void (*)(void *scheduler, int priority, void (^callback)())` — cast back
    to the typed pointer inside `ExpoModulesJSI`. It's typed as `UnsafeRawPointer`

package/ios/Core/Classes/ClassDefinition.swift

@@ -51,17 +51,20 @@ public final class ClassDefinition: ObjectDefinition {
 
   @JavaScriptActor
   public override func build(appContext: AppContext) throws -> JavaScriptObject {
+    // The concrete `SharedObject` subclass backing this class, used to dispatch to the
+    // `@SharedObject` macro's `_constructSharedObject` / `_decorateSharedObject` overrides.
+    let sharedObjectType = ((associatedType as? DynamicSharedObjectType)?.innerType) as? SharedObject.Type
+
     let constructorClosure: JavaScriptRuntime.SyncFunctionClosure = { [weak self, weak appContext] this, arguments in
       guard let self, let appContext else {
         throw Exceptions.AppContextLost()
       }
-      // Call the native constructor when defined. Any thrown `Exception` (which
-      // conforms to `JavaScriptThrowable`) propagates to the host function closure,
-      // which converts it to a JS `Error` preserving `message` and `code`.
-      if let constructor {
-        // Run the body natively so we can pair a returned `SharedObject` with `this`
-        // directly. `this` was created by `new` with the correct class prototype; returning
-        // a different JS object would replace `this` and drop that prototype chain.
+      // Build the native instance and pair it with `this` (returning a different object would drop
+      // the prototype chain `new` set up). Prefer the macro-synthesized `_constructSharedObject`,
+      // falling back to the DSL `Constructor` body.
+      if let sharedObject = try sharedObjectType?._constructSharedObject(this: this, arguments: arguments, in: appContext.runtime) {
+        appContext.sharedObjectRegistry.add(native: sharedObject, javaScript: this.getObject())
+      } else if let constructor {
         let result = try constructor.runBody(appContext, in: appContext.runtime, this: this, arguments: arguments)
 
         if let sharedObject = result as? SharedObject {
@@ -75,6 +78,12 @@ public final class ClassDefinition: ObjectDefinition {
 
     try decorate(object: klass, appContext: appContext)
 
+    // Bind the macro's `@JS` members onto the prototype.
+    if let sharedObjectType {
+      let prototype = klass.getProperty("prototype").getObject()
+      try sharedObjectType._decorateSharedObject(prototype: prototype, in: appContext.runtime)
+    }
+
     // Register the JS class and its associated native type.
     if let sharedObjectType = associatedType as? DynamicSharedObjectType {
       appContext.classRegistry.register(nativeClassId: sharedObjectType.typeIdentifier, javaScriptClass: klass)
@@ -122,6 +131,10 @@ public final class ClassDefinition: ObjectDefinition {
         proto.setProperty(fn.name, value: try syncFn.build(appContext: appContext, in: runtime))
       }
     }
+    // Bind the macro's `@JS` members, which aren't in the DSL `properties`/`functions` dictionaries.
+    if let sharedObjectType = (associatedType as? DynamicSharedObjectType)?.innerType as? SharedObject.Type {
+      try sharedObjectType._decorateSharedObject(prototype: proto, in: runtime)
+    }
     return proto
   }
 }