expo-modules-core 3.0.22 → 3.0.23

package/CHANGELOG.md

@@ -10,6 +10,22 @@
 
 ### 💡 Others
 
+## 3.0.23 — 2025-10-28
+
+### 🎉 New features
+
+- [iOS] Add `applicationDidReceiveMemoryWarning` subscribing to ExpoAppDelegateSubscriberManager ([#40504](https://github.com/expo/expo/pull/40504) by [@szydlovsky](https://github.com/szydlovsky))
+- [iOS] Swift's `Encodable` types can now be converted to JavaScript values. ([#40621](https://github.com/expo/expo/pull/40621) by [@tsapeta](https://github.com/tsapeta))
+
+### 🐛 Bug fixes
+
+- [core] [iOS] Addresses a potential crash where `[NSString UTF8String]` could return `nil` for certain string inputs (non-English), leading to an attempt to dereference a null pointer during `jsi::String` creation. ([#40639](https://github.com/expo/expo/pull/40639) by [@mohammadamin16](https://github.com/mohammadamin16))
+- [Android] Fix `androidNavigationBar.enforceContrast` app config property not working. ([#40263](https://github.com/expo/expo/pull/40263) by [@behenate](https://github.com/behenate))
+
+### 💡 Others
+
+- [iOS] Removed some runtime type checks for dynamic types. ([#40611](https://github.com/expo/expo/pull/40611) by [@tsapeta](https://github.com/tsapeta))
+
 ## 3.0.22 — 2025-10-20
 
 ### 🎉 New features

package/android/build.gradle

@@ -29,7 +29,7 @@ if (shouldIncludeCompose) {
 }
 
 group = 'host.exp.exponent'
-version = '3.0.22'
+version = '3.0.23'
 
 def isExpoModulesCoreTests = {
   Gradle gradle = getGradle()
@@ -79,7 +79,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "3.0.22"
+    versionName "3.0.23"
     buildConfigField "String", "EXPO_MODULES_CORE_VERSION", "\"${versionName}\""
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled.toString()
 

package/android/src/main/java/expo/modules/kotlin/edgeToEdge/EdgeToEdgePackage.kt

@@ -0,0 +1,69 @@
+package expo.modules.kotlin.edgeToEdge
+
+import android.R
+import android.app.Activity
+import android.content.Context
+import android.content.res.TypedArray
+import android.os.Build
+import android.os.Bundle
+import android.util.Log
+import android.view.Window
+import androidx.annotation.RequiresApi
+import expo.modules.core.BasePackage
+import expo.modules.core.interfaces.ReactActivityLifecycleListener
+import kotlin.Unit
+
+class EdgeToEdgePackage : BasePackage() {
+  override fun createReactActivityLifecycleListeners(activityContext: Context?): List<ReactActivityLifecycleListener?>? {
+    return listOf(object : ReactActivityLifecycleListener {
+      override fun onCreate(activity: Activity?, savedInstanceState: Bundle?) {
+        val edgeToEdgeEnabled = invokeWindowUtilKtMethod<Boolean>("isEdgeToEdgeFeatureFlagOn") ?: true
+
+        if (edgeToEdgeEnabled) {
+          invokeWindowUtilKtMethod<Unit>("enableEdgeToEdge", Pair(Window::class.java, activity?.window))
+
+          // React-native sets `window.isNavigationBarContrastEnforced` to `true` in `WindowUtilKt.enableEdgeToEdge`.
+          // We have to set it back to the value defined in the app styles, which comes from our config plugin.
+          activity?.enforceNavigationBarContrastFromTheme()
+        }
+      }
+    })
+  }
+}
+
+@RequiresApi(Build.VERSION_CODES.Q)
+private fun Activity.getEnforceContrastFromTheme(): Boolean {
+  val attrs = intArrayOf(R.attr.enforceNavigationBarContrast)
+  val typedArray: TypedArray = theme.obtainStyledAttributes(attrs)
+
+  return try {
+    typedArray.getBoolean(0, true)
+  } finally {
+    typedArray.recycle()
+  }
+}
+
+private fun Activity.enforceNavigationBarContrastFromTheme() {
+  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+    window.isNavigationBarContrastEnforced = getEnforceContrastFromTheme()
+  }
+}
+
+private inline fun <reified T> invokeWindowUtilKtMethod(
+  methodName: String,
+  vararg args: Pair<Class<*>, Any?>
+): T? {
+  val windowUtilClassName = "com.facebook.react.views.view.WindowUtilKt"
+
+  return runCatching {
+    val windowUtilKtClass = Class.forName(windowUtilClassName)
+    val parameterTypes = args.map { it.first }.toTypedArray()
+    val parameterValues = args.map { it.second }.toTypedArray()
+    val method = windowUtilKtClass.getDeclaredMethod(methodName, *parameterTypes)
+
+    method.isAccessible = true
+    method.invoke(null, *parameterValues) as? T
+  }.onFailure {
+    Log.e("EdgeToEdgePackage", "Failed to invoke '$methodName' on $windowUtilClassName", it)
+  }.getOrNull()
+}

package/ios/AppDelegates/ExpoAppDelegateSubscriberManager.swift

@@ -139,7 +139,18 @@ public class ExpoAppDelegateSubscriberManager: NSObject {
   }
 #endif
 
-  // TODO: - Responding to Environment Changes
+  // MARK: - Responding to Environment Changes
+
+#if os(iOS) || os(tvOS)
+
+  @objc
+  public static func applicationDidReceiveMemoryWarning(_ application: UIApplication) {
+    ExpoAppDelegateSubscriberRepository
+      .subscribers
+      .forEach { $0.applicationDidReceiveMemoryWarning?(application) }
+  }
+
+#endif
 
   // TODO: - Managing App State Restoration
 

package/ios/Core/DynamicTypes/DynamicEncodableType.swift

@@ -0,0 +1,47 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+/**
+ Dynamic type for values conforming to `Encodable` protocol.
+ Note that currently it can only encode from native to JavaScript values, thus cannot be used for arguments.
+ */
+internal struct DynamicEncodableType: AnyDynamicType {
+  static let shared = DynamicEncodableType()
+
+  func wraps<InnerType>(_ type: InnerType.Type) -> Bool {
+    return type is Encodable
+  }
+
+  func equals(_ type: any AnyDynamicType) -> Bool {
+    // Just mocking it here as we don't really need this function and we rather want to keep it a singleton
+    return false
+  }
+
+  func cast<ValueType>(_ value: ValueType, appContext: AppContext) throws -> Any {
+    // TODO: Create DynamicDecodableType and reuse it here – that would work perfectly with Codable types
+    fatalError("DynamicEncodableType can only cast to JavaScript, not from")
+  }
+
+  func castToJS<ValueType>(_ value: ValueType, appContext: AppContext) throws -> JavaScriptValue {
+    if let value = value as? JavaScriptValue {
+      return value
+    }
+    if let value = value as? Encodable {
+      let runtime = try appContext.runtime
+      let encoder = JSValueEncoder(runtime: runtime)
+
+      try value.encode(to: encoder)
+
+      return encoder.value
+    }
+    throw Conversions.ConversionToJSFailedException((kind: .object, nativeType: ValueType.self))
+  }
+
+  func convertResult<ResultType>(_ result: ResultType, appContext: AppContext) throws -> Any {
+    // TODO: We should get rid of this function, but it seems it's still used in some places
+    return try castToJS(result, appContext: appContext)
+  }
+
+  var description: String {
+    "Encodable"
+  }
+}

package/ios/Core/DynamicTypes/DynamicType.swift

@@ -7,54 +7,22 @@
 /**
  Factory creating an instance of the dynamic type wrapper conforming to `AnyDynamicType`.
  Depending on the given type, it may return one of `DynamicArrayType`, `DynamicOptionalType`, `DynamicConvertibleType`, etc.
- Note that this goes through many type checks, thus it might be a bit more expensive than using generic type constraints,
- see the `~` prefix operator below that handles types conforming to `AnyArgument` in a faster way.
+ It does some type checks in runtime when the type's conformance/inheritance is unknown for the compiler.
+ See the `~` prefix operator overloads that are used for types known for the compiler.
+ You can add more type checks for types that don't conform to `AnyArgument`, but are allowed to be used as return types.
+ `Void` is a good example as it cannot conform to anything or language protocols that cannot be extended to implement `AnyArgument`.
  */
 private func DynamicType<T>(_ type: T.Type) -> AnyDynamicType {
-  if type is any Numeric.Type {
-    return DynamicNumberType(numberType: T.self)
-  }
-  if type is String.Type {
-    return DynamicStringType.shared
-  }
-  if let ArrayType = T.self as? AnyArray.Type {
-    return DynamicArrayType(elementType: ArrayType.getElementDynamicType())
-  }
-  if let DictionaryType = T.self as? AnyDictionary.Type {
-    return DynamicDictionaryType(valueType: DictionaryType.getValueDynamicType())
-  }
-  if let OptionalType = T.self as? any AnyOptional.Type {
-    return DynamicOptionalType(wrappedType: OptionalType.getWrappedDynamicType())
-  }
-  if let ConvertibleType = T.self as? Convertible.Type {
-    return DynamicConvertibleType(innerType: ConvertibleType)
-  }
-  if let EnumType = T.self as? any Enumerable.Type {
-    return DynamicEnumType(innerType: EnumType)
-  }
-  if let ViewType = T.self as? UIView.Type {
-    return DynamicViewType(innerType: ViewType)
-  }
-  if let SharedObjectType = T.self as? SharedObject.Type {
-    return DynamicSharedObjectType(innerType: SharedObjectType)
-  }
-  if let TypedArrayType = T.self as? AnyTypedArray.Type {
-    return DynamicTypedArrayType(innerType: TypedArrayType)
-  }
-  if T.self is Data.Type {
-    return DynamicDataType.shared
-  }
-  if let JavaScriptValueType = T.self as? any AnyJavaScriptValue.Type {
-    return DynamicJavaScriptType(innerType: JavaScriptValueType)
+  if let AnyArgumentType = T.self as? AnyArgument.Type {
+    return AnyArgumentType.getDynamicType()
   }
   if T.self == Void.self {
     return DynamicVoidType.shared
   }
-  if let AnyEitherType = T.self as? AnyEither.Type {
-    return AnyEitherType.getDynamicType()
-  }
-  if let AnyValueOrUndefinedType = T.self as? AnyValueOrUndefined.Type {
-    return AnyValueOrUndefinedType.getDynamicType()
+  if T.self is Encodable.Type {
+    // There is no dedicated `~` operator overload for encodables to avoid ambiguity
+    // when the type is both `AnyArgument` and `Encodable` (e.g. strings, numeric types).
+    return DynamicEncodableType.shared
   }
   return DynamicRawType(innerType: T.self)
 }

package/ios/Core/JSValueEncoder.swift

@@ -0,0 +1,201 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+/**
+ Encodes `Encodable` objects or values to `JavaScriptValue`. This implementation is incomplete,
+ but it supports basic use cases with structs defined by the user and when the default `Encodable` implementation is used.
+ */
+internal final class JSValueEncoder: Encoder {
+  private let runtime: JavaScriptRuntime
+  private let valueHolder = JSValueHolder()
+
+  /**
+   The result of encoding to `JavaScriptValue`. Use this property after running `encode(to:)` on the encodable.
+   */
+  var value: JavaScriptValue {
+    return valueHolder.value
+  }
+
+  /**
+   Initializes the encoder with the given runtime in which the value will be created.
+   */
+  init(runtime: JavaScriptRuntime) {
+    self.runtime = runtime
+  }
+
+  // MARK: - Encoder
+
+  // We don't use `codingPath` and `userInfo`, but they are required by the protocol.
+  let codingPath: [any CodingKey] = []
+  let userInfo: [CodingUserInfoKey: Any] = [:]
+
+  /**
+   Returns an encoding container appropriate for holding multiple values keyed by the given key type.
+   */
+  func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key> where Key: CodingKey {
+    let container = JSObjectEncodingContainer<Key>(to: valueHolder, runtime: runtime)
+    return KeyedEncodingContainer(container)
+  }
+
+  /**
+   Returns an encoding container appropriate for holding multiple unkeyed values.
+   */
+  func unkeyedContainer() -> any UnkeyedEncodingContainer {
+    return JSArrayEncodingContainer(to: valueHolder, runtime: runtime)
+  }
+
+  /**
+   Returns an encoding container appropriate for holding a single primitive value, including optionals.
+   */
+  func singleValueContainer() -> any SingleValueEncodingContainer {
+    return JSValueEncodingContainer(to: valueHolder, runtime: runtime)
+  }
+}
+
+/**
+ An object that holds a JS value that could be overriden by the encoding container.
+ */
+private final class JSValueHolder {
+  var value: JavaScriptValue = .undefined
+}
+
+/**
+ Single value container used to encode primitive values, including optionals.
+ */
+private struct JSValueEncodingContainer: SingleValueEncodingContainer {
+  private weak var runtime: JavaScriptRuntime?
+  private let valueHolder: JSValueHolder
+
+  init(to valueHolder: JSValueHolder, runtime: JavaScriptRuntime?) {
+    self.runtime = runtime
+    self.valueHolder = valueHolder
+  }
+
+  // MARK: - SingleValueEncodingContainer
+
+  // Unused, but required by the protocol.
+  let codingPath: [any CodingKey] = []
+
+  mutating func encodeNil() throws {
+    self.valueHolder.value = .null
+  }
+
+  mutating func encode<ValueType: Encodable>(_ value: ValueType) throws {
+    guard let runtime else {
+      // Do nothing when the runtime is already deallocated
+      return
+    }
+    let jsValue = JavaScriptValue.from(value, runtime: runtime)
+
+    // If the given value couldn't be converted to JavaScriptValue, try to encode it farther.
+    // It might be the case when the default implementation of `Encodable` has chosen the single value container
+    // for an optional type that should rather use keyed or unkeyed container when unwrapped.
+    if jsValue.isUndefined() {
+      let encoder = JSValueEncoder(runtime: runtime)
+      try value.encode(to: encoder)
+      self.valueHolder.value = encoder.value
+      return
+    }
+    self.valueHolder.value = jsValue
+  }
+}
+
+/**
+ Keyed container that encodes to a JavaScript object.
+ */
+private struct JSObjectEncodingContainer<Key: CodingKey>: KeyedEncodingContainerProtocol {
+  private weak var runtime: JavaScriptRuntime?
+  private let valueHolder: JSValueHolder
+  private var object: JavaScriptObject
+
+  init(to valueHolder: JSValueHolder, runtime: JavaScriptRuntime) {
+    let object = runtime.createObject()
+    valueHolder.value = JavaScriptValue.from(object, runtime: runtime)
+
+    self.runtime = runtime
+    self.object = object
+    self.valueHolder = valueHolder
+  }
+
+  // MARK: - KeyedEncodingContainerProtocol
+
+  // Unused, but required by the protocol.
+  var codingPath: [any CodingKey] = []
+
+  mutating func encodeNil(forKey key: Key) throws {
+    object.setProperty(key.stringValue, value: JavaScriptValue.null)
+  }
+
+  mutating func encode<ValueType: Encodable>(_ value: ValueType, forKey key: Key) throws {
+    guard let runtime else {
+      // Do nothing when the runtime is already deallocated
+      return
+    }
+    let encoder = JSValueEncoder(runtime: runtime)
+    try value.encode(to: encoder)
+    object.setProperty(key.stringValue, value: encoder.value)
+  }
+
+  mutating func nestedContainer<NestedKey: CodingKey>(keyedBy keyType: NestedKey.Type, forKey key: Key) -> KeyedEncodingContainer<NestedKey> {
+    fatalError("JSValueEncoder does not support nested containers")
+  }
+
+  mutating func nestedUnkeyedContainer(forKey key: Key) -> any UnkeyedEncodingContainer {
+    fatalError("JSValueEncoder does not support nested containers")
+  }
+
+  mutating func superEncoder() -> any Encoder {
+    fatalError("superEncoder() is not implemented in JSValueEncoder")
+  }
+
+  mutating func superEncoder(forKey key: Key) -> any Encoder {
+    return self.superEncoder()
+  }
+}
+
+/**
+ Unkeyed container that encodes values to a JavaScript array.
+ */
+private struct JSArrayEncodingContainer: UnkeyedEncodingContainer {
+  private weak var runtime: JavaScriptRuntime?
+  private let valueHolder: JSValueHolder
+  private var items: [JavaScriptValue] = []
+
+  init(to valueHolder: JSValueHolder, runtime: JavaScriptRuntime) {
+    self.runtime = runtime
+    self.valueHolder = valueHolder
+  }
+
+  // MARK: - UnkeyedEncodingContainer
+
+  // Unused, but required by the protocol.
+  var codingPath: [any CodingKey] = []
+  var count: Int = 0
+
+  mutating func encodeNil() throws {
+    items.append(.null)
+  }
+
+  mutating func encode<ValueType: Encodable>(_ value: ValueType) throws {
+    guard let runtime else {
+      // Do nothing when the runtime is already deallocated
+      return
+    }
+    let encoder = JSValueEncoder(runtime: runtime)
+    try value.encode(to: encoder)
+
+    items.append(encoder.value)
+    valueHolder.value = .from(items, runtime: runtime)
+  }
+
+  mutating func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type) -> KeyedEncodingContainer<NestedKey> where NestedKey : CodingKey {
+    fatalError("JSValueEncoder does not support nested containers")
+  }
+
+  mutating func nestedUnkeyedContainer() -> any UnkeyedEncodingContainer {
+    fatalError("JSValueEncoder does not support nested containers")
+  }
+
+  mutating func superEncoder() -> any Encoder {
+    fatalError("superEncoder() is not implemented in JSValueEncoder")
+  }
+}

package/ios/JSI/EXJSIConversions.mm

@@ -31,7 +31,8 @@ jsi::String convertNSStringToJSIString(jsi::Runtime &runtime, NSString *value)
 #if !TARGET_OS_OSX
   const uint8_t *utf8 = (const uint8_t *)[value UTF8String];
   const size_t length = [value length];
-  if (expo::isAllASCIIAndNotNull(utf8, utf8 + length)) {
+
+  if (utf8 != nullptr && expo::isAllASCIIAndNotNull(utf8, utf8 + length)) {
     return jsi::String::createFromAscii(runtime, (const char *)utf8, length);
   }
   // Using cStringUsingEncoding should be fine as long as we provide the length.

package/ios/JSI/EXJavaScriptValue.h

@@ -60,6 +60,7 @@ NS_SWIFT_NAME(JavaScriptValue)
 #pragma mark - Statics
 
 @property (class, nonatomic, assign, readonly, nonnull) EXJavaScriptValue *undefined;
+@property (class, nonatomic, assign, readonly, nonnull) EXJavaScriptValue *null;
 
 + (nonnull EXJavaScriptValue *)number:(double)value;
 

package/ios/JSI/EXJavaScriptValue.mm

@@ -170,10 +170,14 @@
 
 + (nonnull EXJavaScriptValue *)undefined
 {
-  auto undefined = std::make_shared<jsi::Value>();
   return [[EXJavaScriptValue alloc] initWithRuntime:nil value:jsi::Value::undefined()];
 }
 
++ (nonnull EXJavaScriptValue *)null
+{
+  return [[EXJavaScriptValue alloc] initWithRuntime:nil value:jsi::Value::null()];
+}
+
 + (nonnull EXJavaScriptValue *)number:(double)value
 {
   return [[EXJavaScriptValue alloc] initWithRuntime:nil value:jsi::Value(value)];

package/ios/Tests/DynamicTypeSpec.swift

@@ -405,5 +405,75 @@ final class DynamicTypeSpec: ExpoSpec {
         }
       }
     }
+
+    // MARK: - DynamicEncodableType
+
+    describe("DynamicEncodableType") {
+      struct TestEncodable: Encodable {
+        let string: String
+        let number: Int
+        let bool: Bool
+        var object: TestEncodableChild? = nil
+        var array: [Int]? = nil
+      }
+      struct TestEncodableChild: Encodable {
+        let name: String
+      }
+
+      it("is created") {
+        expect(~TestEncodable.self).to(beAKindOf(DynamicEncodableType.self))
+      }
+      it("casts to JS object") {
+        let encodable = TestEncodable(string: "test", number: -5, bool: true)
+        let result = try (~TestEncodable.self).castToJS(encodable, appContext: appContext)
+
+        expect(result.kind) == .object
+      }
+      it("has proper property names") {
+        let encodable = TestEncodable(string: "test", number: -5, bool: true)
+        let result = try (~TestEncodable.self).castToJS(encodable, appContext: appContext)
+        let propertyNames = result.getObject().getPropertyNames()
+
+        expect(propertyNames.count) == 3
+        expect(propertyNames).to(contain(["string", "number", "bool"]))
+      }
+      it("has correct values") {
+        let encodable = TestEncodable(string: "test", number: -5, bool: true)
+        let result = try (~TestEncodable.self).castToJS(encodable, appContext: appContext)
+        let object = result.getObject()
+
+        expect(try object.getProperty("string").asString()) == encodable.string
+        expect(try object.getProperty("number").asInt()) == encodable.number
+        expect(try object.getProperty("bool").asBool()) == encodable.bool
+        expect(object.getProperty("object").isUndefined()) == true
+        expect(object.getProperty("array").isUndefined()) == true
+      }
+      it("casts nested objects") {
+        let encodable = TestEncodable(
+          string: "test",
+          number: -5,
+          bool: true,
+          object: TestEncodableChild(name: "expo")
+        )
+        let result = try (~TestEncodable.self).castToJS(encodable, appContext: appContext)
+        let nestedValue = result.getObject().getProperty("object")
+
+        expect(nestedValue.kind) == .object
+        expect(try nestedValue.getObject().getProperty("name").asString()) == encodable.object?.name
+      }
+      it("casts arrays") {
+        let encodable = TestEncodable(
+          string: "test",
+          number: -5,
+          bool: true,
+          array: [1, 2, 3]
+        )
+        let result = try (~TestEncodable.self).castToJS(encodable, appContext: appContext)
+        let array = result.getObject().getProperty("array").getArray()
+
+        expect(array.count) == encodable.array?.count
+        expect(array.map({ $0.getInt() })) == encodable.array
+      }
+    }
   }
 }

package/ios/Tests/FunctionSpec.swift

@@ -252,6 +252,11 @@ class FunctionSpec: ExpoSpec {
         @Field var url: URL = defaultURL
       }
 
+      struct TestEncodable: Encodable {
+        let name: String
+        let version: Int
+      }
+
       afterEach {
         try runtime.eval("globalThis.result = undefined")
       }
@@ -309,6 +314,10 @@ class FunctionSpec: ExpoSpec {
             return "\(f?.property ?? "no value")"
           }
 
+          Function("returnEncodable") {
+            return TestEncodable(name: "Expo SDK", version: 55)
+          }
+
           Function("withSharedObject") {
             return SharedString("Test")
           }
@@ -388,6 +397,14 @@ class FunctionSpec: ExpoSpec {
         expect(try runtime.eval("expo.modules.TestModule.withOptionalRecord({property: \"123\"})").asString()) == "123"
       }
 
+      it("returns encodable struct") {
+        let result = try runtime.eval("expo.modules.TestModule.returnEncodable()")
+        expect(result.kind) == .object
+        expect(result.getObject().getPropertyNames()).to(contain(["name", "version"]))
+        expect(try result.getObject().getProperty("name").asString()) == "Expo SDK"
+        expect(try result.getObject().getProperty("version").asInt()) == 55
+      }
+
       it("returns URL (sync)") {
         let result = try runtime.eval("globalThis.result = expo.modules.TestModule.withURL()")
         expect(result.kind) == .string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "3.0.22",
+  "version": "3.0.23",
   "description": "The core of Expo Modules architecture",
   "main": "src/index.ts",
   "types": "build/index.d.ts",
@@ -65,5 +65,5 @@
     "@testing-library/react-native": "^13.2.0",
     "expo-module-scripts": "^5.0.7"
   },
-  "gitHead": "ea56136a4420322f46d00e4b1549595d8f85150e"
+  "gitHead": "f1475b7bd0e8fdec0c0027be89c4c8d650d10805"
 }