expo-modules-core 57.0.2 → 57.0.4

package/ios/Core/Convertibles/Convertibles+Color.swift

@@ -28,7 +28,8 @@ extension UIColor: Convertible {
     // Handle `PlatformColor` and `DynamicColorIOS`
     if let opaqueValue = value as? [String: Any] {
       if let semanticName = opaqueValue["semantic"] as? String,
-        let color = resolveNamedColor(name: semanticName) {
+        let color = resolveNamedColor(name: semanticName)
+      {
         return color as! Self
       }
       if let semanticArray = opaqueValue["semantic"] as? [String] {
@@ -40,7 +41,8 @@ extension UIColor: Convertible {
       }
       if let appearances = opaqueValue["dynamic"] as? [String: Any],
         let lightColor = try appearances["light"].map({ try UIColor.convert(from: $0) }),
-        let darkColor = try appearances["dark"].map({ try UIColor.convert(from: $0) }) {
+        let darkColor = try appearances["dark"].map({ try UIColor.convert(from: $0) })
+      {
         let highContrastLightColor = try appearances["highContrastLight"].map({ try UIColor.convert(from: $0) })
         let highContrastDarkColor = try appearances["highContrastDark"].map({ try UIColor.convert(from: $0) })
 
@@ -166,9 +168,7 @@ private func uiColorWithComponents(_ components: [Double]) throws -> UIColor {
 
 // MARK: - Color String Parsing
 
-/**
- Parses a color string (hex, rgb, hsl, hwb) into a UIColor.
- */
+/// Parses a color string (hex, rgb, hsl, hwb) into a UIColor.
 private func colorFromString(_ value: String) throws -> UIColor {
   let input = value.trimmingCharacters(in: .whitespacesAndNewlines)
   let lowercased = input.lowercased()
@@ -233,80 +233,183 @@ private func colorFromRgba(_ rgba: UInt64) throws -> UIColor {
 
 // MARK: - CSS Color Function Regex Patterns
 
-nonisolated(unsafe) private let cssNumber = /[-+]?\d*\.?\d+/
-nonisolated(unsafe) private let cssNumberOrPercent = /[-+]?\d*\.?\d+%?/
+// These are built from RegexBuilder primitives only. Composing regex-literal fragments
+// (e.g. /hsla?\(\s*/) inside a builder miscompiles on some OS runtime versions
+// (observed on the iOS 27.0 beta simulator) and the patterns silently stop matching.
+
+/// A CSS number like `-12`, `+1.5`, `.5` or `100`.
+nonisolated(unsafe) private let cssNumber = Regex {
+  Optionally {
+    CharacterClass.anyOf("-+")
+  }
+  ZeroOrMore(.digit)
+  Optionally {
+    "."
+  }
+  OneOrMore(.digit)
+}
+
+nonisolated(unsafe) private let cssNumberOrPercent = Regex {
+  cssNumber
+  Optionally {
+    "%"
+  }
+}
+
+nonisolated(unsafe) private let commaSeparator = Regex {
+  ZeroOrMore(.whitespace)
+  ","
+  ZeroOrMore(.whitespace)
+}
 
 nonisolated(unsafe) private let rgbCommaRegex = Regex {
-  /rgba?\(\s*/
-  Capture { cssNumberOrPercent }
-  /\s*,\s*/
-  Capture { cssNumberOrPercent }
-  /\s*,\s*/
-  Capture { cssNumberOrPercent }
+  "rgb"
   Optionally {
-    /\s*,\s*/
-    Capture { cssNumberOrPercent }
+    "a"
+  }
+  "("
+  ZeroOrMore(.whitespace)
+  Capture {
+    cssNumberOrPercent
+  }
+  commaSeparator
+  Capture {
+    cssNumberOrPercent
+  }
+  commaSeparator
+  Capture {
+    cssNumberOrPercent
   }
-  /\s*\)/
+  Optionally {
+    commaSeparator
+    Capture {
+      cssNumberOrPercent
+    }
+  }
+  ZeroOrMore(.whitespace)
+  ")"
 }.ignoresCase()
 
 nonisolated(unsafe) private let rgbSpaceRegex = Regex {
-  /rgba?\(\s*/
-  Capture { cssNumberOrPercent }
-  /\s+/
-  Capture { cssNumberOrPercent }
-  /\s+/
-  Capture { cssNumberOrPercent }
+  "rgb"
   Optionally {
-    /\s*\/\s*/
-    Capture { cssNumberOrPercent }
+    "a"
+  }
+  "("
+  ZeroOrMore(.whitespace)
+  Capture {
+    cssNumberOrPercent
   }
-  /\s*\)/
+  OneOrMore(.whitespace)
+  Capture {
+    cssNumberOrPercent
+  }
+  OneOrMore(.whitespace)
+  Capture {
+    cssNumberOrPercent
+  }
+  Optionally {
+    ZeroOrMore(.whitespace)
+    "/"
+    ZeroOrMore(.whitespace)
+    Capture {
+      cssNumberOrPercent
+    }
+  }
+  ZeroOrMore(.whitespace)
+  ")"
 }.ignoresCase()
 
 nonisolated(unsafe) private let hslCommaRegex = Regex {
-  /hsla?\(\s*/
-  Capture { cssNumber }
-  /\s*,\s*/
-  Capture { cssNumber }
-  /%\s*,\s*/
-  Capture { cssNumber }
-  /%\s*/
+  "hsl"
+  Optionally {
+    "a"
+  }
+  "("
+  ZeroOrMore(.whitespace)
+  Capture {
+    cssNumber
+  }
+  commaSeparator
+  Capture {
+    cssNumber
+  }
+  "%"
+  commaSeparator
+  Capture {
+    cssNumber
+  }
+  "%"
+  ZeroOrMore(.whitespace)
   Optionally {
-    /,\s*/
-    Capture { cssNumberOrPercent }
+    ","
+    ZeroOrMore(.whitespace)
+    Capture {
+      cssNumberOrPercent
+    }
   }
-  /\s*\)/
+  ZeroOrMore(.whitespace)
+  ")"
 }.ignoresCase()
 
 nonisolated(unsafe) private let hslSpaceRegex = Regex {
-  /hsla?\(\s*/
-  Capture { cssNumber }
-  /\s+/
-  Capture { cssNumber }
-  /%\s+/
-  Capture { cssNumber }
-  /%\s*/
+  "hsl"
   Optionally {
-    /\/\s*/
-    Capture { cssNumberOrPercent }
+    "a"
+  }
+  "("
+  ZeroOrMore(.whitespace)
+  Capture {
+    cssNumber
+  }
+  OneOrMore(.whitespace)
+  Capture {
+    cssNumber
+  }
+  "%"
+  OneOrMore(.whitespace)
+  Capture {
+    cssNumber
   }
-  /\s*\)/
+  "%"
+  ZeroOrMore(.whitespace)
+  Optionally {
+    "/"
+    ZeroOrMore(.whitespace)
+    Capture {
+      cssNumberOrPercent
+    }
+  }
+  ZeroOrMore(.whitespace)
+  ")"
 }.ignoresCase()
 
 nonisolated(unsafe) private let hwbRegex = Regex {
-  /hwb\(\s*/
-  Capture { cssNumber }
-  /\s+/
-  Capture { cssNumber }
-  /%\s+/
-  Capture { cssNumber }
-  /%\s*/
+  "hwb("
+  ZeroOrMore(.whitespace)
+  Capture {
+    cssNumber
+  }
+  OneOrMore(.whitespace)
+  Capture {
+    cssNumber
+  }
+  "%"
+  OneOrMore(.whitespace)
+  Capture {
+    cssNumber
+  }
+  "%"
+  ZeroOrMore(.whitespace)
   Optionally {
-    /\/\s*/
-    Capture { cssNumberOrPercent }
+    "/"
+    ZeroOrMore(.whitespace)
+    Capture {
+      cssNumberOrPercent
+    }
   }
-  /\s*\)/
+  ZeroOrMore(.whitespace)
+  ")"
 }.ignoresCase()
 
 // MARK: - CSS Color Function Parsers
@@ -387,8 +490,7 @@ private func hwbToUIColor(h: CGFloat, w: CGFloat, b: CGFloat, a: CGFloat) -> UIC
 }
 
 private func colorFromRGBString(_ rgbString: String) throws -> UIColor {
-  if let match = rgbString.wholeMatch(of: rgbCommaRegex) ?? rgbString.wholeMatch(of: rgbSpaceRegex)
-  {
+  if let match = rgbString.wholeMatch(of: rgbCommaRegex) ?? rgbString.wholeMatch(of: rgbSpaceRegex) {
     let r = parseRgbComponent(match.1)
     let g = parseRgbComponent(match.2)
     let b = parseRgbComponent(match.3)
@@ -399,8 +501,7 @@ private func colorFromRGBString(_ rgbString: String) throws -> UIColor {
 }
 
 private func colorFromHSLString(_ hslString: String) throws -> UIColor {
-  if let match = hslString.wholeMatch(of: hslCommaRegex) ?? hslString.wholeMatch(of: hslSpaceRegex)
-  {
+  if let match = hslString.wholeMatch(of: hslCommaRegex) ?? hslString.wholeMatch(of: hslSpaceRegex) {
     let h = CGFloat(Double(match.1) ?? 0)
     let s = CGFloat(min(max((Double(match.2) ?? 0) / 100.0, 0), 1))
     let l = CGFloat(min(max((Double(match.3) ?? 0) / 100.0, 0), 1))
@@ -421,10 +522,8 @@ private func colorFromHWBString(_ hwbString: String) throws -> UIColor {
   throw InvalidHWBColorException(hwbString)
 }
 
-/**
- Color components for named colors following the [CSS3/SVG specification](https://www.w3.org/TR/css-color-3/#svg-color)
- and additionally the transparent color.
- */
+/// Color components for named colors following the [CSS3/SVG specification](https://www.w3.org/TR/css-color-3/#svg-color)
+/// and additionally the transparent color.
 private let namedColors: [String: [Double]] = [
   "aliceblue": [240, 248, 255, 255],
   "antiquewhite": [250, 235, 215, 255],

package/ios/Core/ExpoModulesMacros.swift

@@ -71,7 +71,7 @@ public macro Event(_ name: String? = nil, sync: Bool = false) =
 /// `expo-modules-core` calls it automatically and merges the result into the module's
 /// definition, so the user doesn't have to reference it from `definition()`. `@JS` functions are
 /// additionally bound directly into the module's JS object by a synthesized
-/// `_decorateModule(object:in:appContext:)`.
+/// `_decorateModule(object:in:)`.
 ///
 /// The module's JavaScript name is synthesized into a `_jsName` static and read by core, so there
 /// is no `Name(…)` DSL entry. It defaults to the class name; pass `@ExpoModule("CustomName")` to
@@ -100,6 +100,12 @@ public macro ExpoModule(_ name: String? = nil, classes: [Any.Type] = []) =
 /// The companion `@ExpoModule(classes: [Foo.self])` wires the class into the module's
 /// exposed surface.
 ///
+/// `@JS` methods and properties are bound directly onto the class prototype by an override of
+/// `_decorateSharedObject(prototype:in:)`, and a single `@JS init(...)` becomes an override
+/// of `_constructSharedObject(this:arguments:in:)` that builds the native instance from the
+/// JS arguments. Core calls both when building the class, so the synthesized `Class(…)` block carries
+/// no DSL entries for the `@JS` members.
+///
 /// Usage:
 ///
 ///     @SharedObject
@@ -113,7 +119,10 @@ public macro ExpoModule(_ name: String? = nil, classes: [Any.Type] = []) =
 ///       @JS
 ///       var size: Int { 42 }
 ///     }
-@attached(member, names: named(_synthesizedClassDefinition))
+@attached(
+  member,
+  names:
+    named(_synthesizedClassDefinition), named(_decorateSharedObject), named(_constructSharedObject))
 @attached(memberAttribute)
 public macro SharedObject(_ name: String? = nil) =
   #externalMacro(module: "ExpoModulesMacros", type: "SharedObjectMacro")

package/ios/Core/Functions/ConcurrentFunctionDefinition.swift

@@ -57,15 +57,20 @@ public class ConcurrentFunctionDefinition<Args, FirstArgType, ReturnType>: AnyCo
 
   @JavaScriptActor
   func call(_ appContext: AppContext, this: JavaScriptValue, arguments: consuming JavaScriptValuesBuffer) async throws -> JavaScriptValue {
+    let argumentsTuple: Args
     do {
-      try validateArgumentsNumber(function: self, received: arguments.count)
-
-      // Arguments must be converted on the JS thread, before we jump to another thread.
-      let nativeArguments = try toNativeClosureArguments(converter: appContext.converter, fn: self, this: this, arguments: arguments)
+      argumentsTuple = try decodeArguments(appContext: appContext, this: this, arguments: arguments)
+    } catch let error as Exception {
+      throw FunctionCallException(name).causedBy(error)
+    } catch {
+      throw UnexpectedException(error)
+    }
+    return try await call(appContext, argumentsTuple: argumentsTuple)
+  }
 
-      guard let argumentsTuple: Args = try Conversions.toTuple(nativeArguments) else {
-        throw ArgumentConversionException()
-      }
+  @JavaScriptActor
+  private func call(_ appContext: AppContext, argumentsTuple: sending Args) async throws -> JavaScriptValue {
+    do {
       // Safe to mark as nonisolated(unsafe) — the tuple contains fully converted native values
       // with no references back to JS objects, so it can safely cross the actor boundary.
       nonisolated(unsafe) let nonisolatedArgumentsTuple = argumentsTuple
@@ -90,16 +95,57 @@ public class ConcurrentFunctionDefinition<Args, FirstArgType, ReturnType>: AnyCo
 
   @JavaScriptActor
   func build(appContext: AppContext) throws -> JavaScriptObject {
-    return try appContext.runtime.createAsyncFunction(name) { [weak appContext, self] this, arguments in
+    return try appContext.runtime.createFunction(name) { [weak appContext, self] this, arguments in
       guard let appContext else {
         throw Exceptions.AppContextLost()
       }
-      return try await self.call(appContext, this: this, arguments: arguments)
+
+      let runtime = try appContext.runtime
+      let promise = try JavaScriptPromise(runtime)
+      let argumentsTuple: Args
+
+      do {
+        argumentsTuple = try self.decodeArguments(appContext: appContext, this: this, arguments: arguments)
+      } catch let error as Exception {
+        promise.reject(FunctionCallException(self.name).causedBy(error))
+        return promise.asValue()
+      } catch {
+        promise.reject(UnexpectedException(error))
+        return promise.asValue()
+      }
+
+      runtime.schedule {
+        do {
+          let result = try await self.call(appContext, argumentsTuple: argumentsTuple)
+          promise.resolve(result)
+        } catch {
+          promise.reject(error)
+        }
+      }
+
+      return promise.asValue()
     }.asObject()
   }
 
   // MARK: - Privates
 
+  @JavaScriptActor
+  private func decodeArguments(
+    appContext: AppContext,
+    this: JavaScriptValue,
+    arguments: consuming JavaScriptValuesBuffer
+  ) throws -> Args {
+    try validateArgumentsNumber(function: self, received: arguments.count)
+
+    let nativeArguments = try toNativeClosureArguments(converter: appContext.converter, fn: self, this: this, arguments: arguments)
+
+    guard let argumentsTuple: Args = try Conversions.toTuple(nativeArguments) else {
+      throw ArgumentConversionException()
+    }
+
+    return argumentsTuple
+  }
+
   @MainActor
   private func callBodyOnMainActor(_ args: sending Args) async throws -> sending ReturnType {
     return try await body(args)

package/ios/Core/ModuleHolder.swift

@@ -139,7 +139,7 @@ public final class ModuleHolder {
 
       // Install the `@JS` members the `@ExpoModule` macro binds directly into the JS object
       // (the direct-JSI path). A no-op for modules that don't use the macro.
-      try module._decorateModule(object: object, in: appContext.runtime, appContext: appContext)
+      try module._decorateModule(object: object, in: appContext.runtime)
 
       return object
     } catch {

package/ios/Core/Protocols/AnyModule.swift

@@ -34,7 +34,7 @@ public protocol AnyModule: AnyObject, AnyArgument {
   /// host functions are installed alongside the DSL-described surface. Framework-internal
   /// (leading underscore). Modules that don't use the macro fall back to the default no-op.
   @JavaScriptActor
-  func _decorateModule(object: borrowing JavaScriptObject, in runtime: JavaScriptRuntime, appContext: AppContext) throws
+  func _decorateModule(object: borrowing JavaScriptObject, in runtime: JavaScriptRuntime) throws
 }
 
 public extension AnyModule {
@@ -53,7 +53,7 @@ public extension AnyModule {
   }
 
   @JavaScriptActor
-  func _decorateModule(object: borrowing JavaScriptObject, in runtime: JavaScriptRuntime, appContext: AppContext) throws {
+  func _decorateModule(object: borrowing JavaScriptObject, in runtime: JavaScriptRuntime) throws {
     // No-op by default — only `@ExpoModule`-macro modules synthesize a real implementation.
   }
 }

package/ios/Core/SharedObjects/SharedObject.swift

@@ -83,6 +83,20 @@ open class SharedObject: AnySharedObject {
   public func emit<P: AnyArgument>(event: String, arguments: sending P) {
     emit(event: event, payload: arguments)
   }
+
+  // MARK: - Macro-synthesized JSI hooks
+
+  /// Binds the class's `@JS` members onto its JavaScript prototype. Overridden by the `@SharedObject`
+  /// macro; a `class func` (not a protocol requirement) so dispatch resolves per subclass.
+  @JavaScriptActor
+  open class func _decorateSharedObject(prototype: borrowing JavaScriptObject, in runtime: JavaScriptRuntime) throws {}
+
+  /// Builds a native instance from the JS constructor arguments, or `nil` to use the DSL `Constructor`
+  /// path. Overridden by the `@SharedObject` macro from the class's `@JS init`.
+  @JavaScriptActor
+  open class func _constructSharedObject(this: JavaScriptValue, arguments: borrowing JavaScriptValuesBuffer, in runtime: JavaScriptRuntime) throws -> SharedObject? {
+    return nil
+  }
 }
 
 extension SharedObject: EventEmitter {

package/ios/Core/SharedObjects/SharedObjectNativeState.swift

@@ -2,24 +2,52 @@
 
 import ExpoModulesJSI
 
-/**
- Native state subclass attached to a SharedObject's JS object. Holds the paired
- native `SharedObject` so callers that already have the JS object can recover
- the native counterpart via `JavaScriptObject.getNativeState(as:)` without going
- through `SharedObjectRegistry`.
- */
+/// Native state attached to a `SharedObject`'s JS object(s). Holds the paired native `SharedObject` so
+/// callers that already have the JS object can recover the native counterpart via
+/// `JavaScriptObject.getNativeState(as:)` without going through `SharedObjectRegistry`.
+///
+/// A single instance is shared across every runtime the native object is exposed to: its underlying C++
+/// `jsi::NativeState` is attached to each runtime's JS object (the same `shared_ptr`, reused via
+/// `JavaScriptNativeState.acquireShared`), and this instance maps each runtime to its paired JS object so
+/// the native object can recover *its* JS counterpart in any given runtime.
 internal final class SharedObjectNativeState: JavaScriptNativeState {
   internal let native: SharedObject
 
-  /**
-   Weak reference to the JS object this native state is attached to. Populated
-   right after `setNativeState` so callers can recover the JS object from the
-   native side without going through `SharedObjectRegistry`.
-   */
-  internal var pairedWeakObject: JavaScriptWeakObject?
+  /// The JS object paired with the native object in each runtime, keyed by runtime identity and held
+  /// weakly. One native object can be exposed to several runtimes (e.g. the main and UI runtimes, or
+  /// worklet contexts), each with its own JS counterpart.
+  private var pairedObjects: [JavaScriptRuntime.ID: JavaScriptRef<JavaScriptWeakObject>] = [:]
 
   internal init(native: SharedObject, factory: @escaping JavaScriptNativeState.Factory) {
     self.native = native
     super.init(factory: factory)
   }
+
+  /// Records `jsObject` as the native object's JS counterpart in `runtime`. The caller is responsible
+  /// for having attached this native state to `jsObject` (`jsObject.setNativeState(self)`), which reuses
+  /// the shared C++ pointee across runtimes.
+  internal func setJavaScriptObject(_ jsObject: borrowing JavaScriptObject, in runtime: JavaScriptRuntime) {
+    // Drop entries whose runtime or JS object has gone away before inserting, so the map doesn't
+    // accumulate dead keys for runtimes that paired once and were torn down.
+    pruneExpired()
+    pairedObjects[runtime.id] = jsObject.createWeak().ref()
+  }
+
+  /// Returns the JS object paired with the native object in `runtime`, or `nil` if there is no live
+  /// pairing there (none was created, or the JS object has been garbage-collected).
+  internal func javaScriptObject(in runtime: JavaScriptRuntime) -> JavaScriptObject? {
+    // Unwrap the ref first so the dictionary subscript's optional doesn't nest with `withValue`'s,
+    // which would form a `JavaScriptObject??` that the non-`Copyable` element can't be wrapped in.
+    guard let ref = pairedObjects[runtime.id] else {
+      return nil
+    }
+    return ref.withValue { $0?.lock() }
+  }
+
+  private func pruneExpired() {
+    pairedObjects = pairedObjects.filter { _, ref in
+      // Keep the entry only while its weak JS object still resolves; an empty ref is dropped.
+      return ref.withValue { $0?.lock() != nil } ?? false
+    }
+  }
 }