expo-modules-core 3.0.22 → 3.0.24

package/CHANGELOG.md

@@ -10,6 +10,33 @@
 
 ### 💡 Others
 
+## 3.0.24 — 2025-11-03
+
+### 🎉 New features
+
+- [iOS] Added `subscriberDidRegister` function to AppDelegate subscribers. ([#40684](https://github.com/expo/expo/pull/40684) by [@tsapeta](https://github.com/tsapeta))
+
+### 🐛 Bug fixes
+
+- [iOS] Fix `Either` conversion in `Record` ([#40655](https://github.com/expo/expo/pull/40655) by [@vonovak](https://github.com/vonovak))
+
+## 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))
+- [iOS] Added base props support for SwiftUI integration. ([#40492](https://github.com/expo/expo/pull/40492) by [@kudo](https://github.com/kudo))
+
 ## 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.24'
 
 def isExpoModulesCoreTests = {
   Gradle gradle = getGradle()
@@ -79,7 +79,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "3.0.22"
+    versionName "3.0.24"
     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/Api/Builders/ViewDefinitionBuilder.swift

@@ -15,7 +15,7 @@ public struct ViewDefinitionBuilder<ViewType: UIView> {
   }
 
   /**
-   Accepts `Events` definition element of `View`.
+   Accepts `ViewName` definition element of `View`.
    */
   public static func buildExpression(_ element: ViewNameDefinition) -> AnyViewDefinitionElement {
     return element

package/ios/AppDelegates/ExpoAppDelegateSubscriber.swift

@@ -24,6 +24,14 @@ open class BaseExpoAppDelegateSubscriber: UIResponder {
 @objc(EXAppDelegateSubscriberProtocol)
 public protocol ExpoAppDelegateSubscriberProtocol: UIApplicationDelegate {
   @objc optional func customizeRootView(_ rootView: UIView)
+
+  /**
+   Function that is called automatically by the `ExpoAppDelegate` once the subscriber is successfully registered.
+   If the subscriber is loaded from the modules provider, it is executed just before the main code of the app,
+   thus even before any other `UIApplicationDelegate` function. Use it if your subscriber needs to run some code as early as possible,
+   but keep in mind that this affects the application loading time.
+   */
+  @objc optional func subscriberDidRegister()
 }
 
 /**

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/AppDelegates/ExpoAppDelegateSubscriberRepository.swift

@@ -32,6 +32,7 @@ public class ExpoAppDelegateSubscriberRepository: NSObject {
       fatalError("Given app delegate subscriber `\(String(describing: subscriber))` is already registered.")
     }
     _subscribers.append(subscriber)
+    subscriber.subscriberDidRegister?()
   }
 
   @objc

package/ios/Core/Arguments/Either.swift

@@ -15,6 +15,11 @@ protocol AnyEither: AnyArgument {
    A dynamic either type for the current either type.
    */
   static func getDynamicType() -> any AnyDynamicType
+
+  /**
+   The underlying type-erased value.
+   */
+  var value: Any? { get }
 }
 
 /*

package/ios/Core/DynamicTypes/DynamicEitherType.swift

@@ -40,6 +40,23 @@ internal struct DynamicEitherType<EitherType: AnyEither>: AnyDynamicType {
     throw NeitherTypeException(types)
   }
 
+  func convertResult<ResultType>(_ result: ResultType, appContext: AppContext) throws -> Any {
+    guard let either = result as? EitherType else {
+      throw Conversions.CastingException<EitherType>(result)
+    }
+
+    let types = eitherType.dynamicTypes()
+
+    // Try each type - one should succeed
+    for type in types {
+      if let converted = try? type.convertResult(either.value, appContext: appContext) {
+        return converted
+      }
+    }
+
+    throw NeitherTypeException(types)
+  }
+
   var description: String {
     let types = eitherType.dynamicTypes()
     return "Either<\(types.map(\.description).joined(separator: ", "))>"

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/Core/Records/Record.swift

@@ -68,12 +68,25 @@ public extension Record {
   }
 }
 
+/**
+ Recursively collects all children from a Mirror, including inherited properties from superclasses.
+ */
+internal func allMirrorChildren(_ mirror: Mirror) -> [Mirror.Child] {
+  var children: [Mirror.Child] = Array(mirror.children)
+  if let superclassMirror = mirror.superclassMirror {
+    children.append(contentsOf: allMirrorChildren(superclassMirror))
+  }
+  return children
+}
+
 /**
  Returns an array of fields found in record's mirror. If the field is missing the `key`,
  it gets assigned to the property label, so after all it's safe to enforce unwrapping it (using `key!`).
+ This function now supports inheritance by recursively traversing the superclass hierarchy.
  */
 internal func fieldsOf(_ record: Record) -> [AnyFieldInternal] {
-  return Mirror(reflecting: record).children.compactMap { (label: String?, value: Any) in
+  let mirror = Mirror(reflecting: record)
+  return allMirrorChildren(mirror).compactMap { (label: String?, value: Any) in
     guard var field = value as? AnyFieldInternal, let key = field.key ?? convertLabelToKey(label) else {
       return nil
     }

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

@@ -113,7 +113,7 @@ extension ExpoSwiftUI {
     }
 
     public override func getSupportedPropNames() -> [String] {
-      return dummyPropsMirror.children.compactMap { (label: String?, value: Any) in
+      return allMirrorChildren(dummyPropsMirror).compactMap { (label: String?, value: Any) in
         guard let field = value as? AnyFieldInternal else {
           return nil
         }
@@ -122,14 +122,13 @@ extension ExpoSwiftUI {
     }
 
     public override func getSupportedEventNames() -> [String] {
-      let builtInEventNames = [GLOBAL_EVENT_NAME]
-      let propEventNames: [String] = dummyPropsMirror.children.compactMap { (label: String?, value: Any) in
+      let propEventNames: [String] = allMirrorChildren(dummyPropsMirror).compactMap { (label: String?, value: Any) in
         guard let event = value as? EventDispatcher else {
           return nil
         }
         return event.customName ?? convertLabelToKey(label)
       }
-      return builtInEventNames + propEventNames
+      return propEventNames
     }
   }
 }

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

@@ -10,6 +10,13 @@ extension ExpoSwiftUI {
       return elements
     }
 
+    /**
+     Accepts `ViewName` definition element of `View`.
+     */
+    public static func buildExpression(_ element: ViewNameDefinition) -> AnyViewDefinitionElement {
+      return element
+    }
+
     /**
      Accepts functions as a view definition elements.
      */

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

@@ -15,7 +15,7 @@ extension ExpoSwiftUI {
     /**
      An array of views passed by React as children.
      */
-    @Field public var children: [any AnyChild]?
+    public var children: [any AnyChild]?
 
     public internal(set) weak var appContext: AppContext?
 
@@ -37,7 +37,8 @@ extension ExpoSwiftUI {
         dispatcher(GLOBAL_EVENT_NAME, payload)
       }
 
-      Mirror(reflecting: self).children.forEach { (label: String?, value: Any) in
+      let mirror = Mirror(reflecting: self)
+      allMirrorChildren(mirror).forEach { (label: String?, value: Any) in
         guard let event = value as? EventDispatcher else {
           return
         }

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")
           }
@@ -325,6 +334,10 @@ class FunctionSpec: ExpoSpec {
             p.resolve(SharedString("Test with Promise"))
           }
 
+          Function("withEither") { (either: Either<Bool, String>) in
+            return either
+          }
+
           AsyncFunction("withURLAsync") {
             return TestURLRecord.defaultURL
           }
@@ -388,6 +401,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
@@ -487,7 +508,17 @@ class FunctionSpec: ExpoSpec {
         expect(result.kind) == .string
         expect(result.getString()) == "Test with Promise"
       }
-      
+
+      it("accepts and returns Either value") {
+        let stringResult = try runtime.eval("expo.modules.TestModule.withEither('test string')")
+        expect(stringResult.kind) == .string
+        expect(stringResult.getString()) == "test string"
+
+        let boolResult = try runtime.eval("expo.modules.TestModule.withEither(true)")
+        expect(boolResult.kind) == .bool
+        expect(boolResult.getBool()) == true
+      }
+
       // For async tests, this is a safe way to repeatedly evaluate JS
       // and catch both Swift and ObjC exceptions
       func safeBoolEval(_ js: String) -> Bool {

package/ios/Tests/RecordSpec.swift

@@ -45,6 +45,31 @@ class RecordSpec: ExpoSpec {
       expect(record.toDictionary()["b"] as? Int).to(equal(dict["b"]! as! Int))
     }
 
+    it("works back and forth with Either") {
+      struct TestRecord: Record {
+        @Field var stringValue: Either<Bool, String>?
+        @Field var boolValue: Either<Bool, String>?
+        @Field var intValue: Either<Int, String>?
+        @Field var nilValue: Either<Int, String>?
+      }
+      let dict: [String: Any] = [
+        "stringValue": "custom",
+        "boolValue": true,
+        "intValue": 42,
+      ]
+      let record = try TestRecord(from: dict, appContext: appContext)
+      expect(record.stringValue?.get() as String?).to(equal("custom"))
+      expect(record.boolValue?.get() as Bool?).to(equal(true))
+      expect(record.intValue?.get() as Int?).to(equal(42))
+      expect(record.nilValue).to(beNil())
+
+      let asDict = record.toDictionary(appContext: appContext)
+      expect(asDict["stringValue"] as? String).to(equal("custom"))
+      expect(asDict["boolValue"] as? Bool).to(equal(true))
+      expect(asDict["intValue"] as? Int).to(equal(42))
+      expect(asDict["nilValue"] as? Int).to(beNil())
+    }
+
     it("works back and forth with a keyed field") {
       struct TestRecord: Record {
         @Field("key") var a: String?

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "3.0.22",
+  "version": "3.0.24",
   "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": "1bba12a43e14a442f2cf1c73fe21968e0ef097c1"
 }