expo-modules-jsi 58.0.7 → 58.0.8

package/apple/Tests/JavaScriptRuntimeCacheTests.swift

@@ -0,0 +1,117 @@
+import ExpoModulesJSI
+import Testing
+
+private final class CachedBox {
+  let value: Int
+
+  init(_ value: Int) {
+    self.value = value
+  }
+}
+
+@Suite
+@JavaScriptActor
+struct JavaScriptRuntimeCacheTests {
+  let runtime = JavaScriptRuntime()
+
+  @Test
+  func `creates the value on first use and reuses it afterwards`() {
+    let key = JavaScriptRuntime.Cache.Key<CachedBox>()
+    var makeCount = 0
+
+    let first = runtime.cached(key) {
+      makeCount += 1
+      return CachedBox(1)
+    }
+    let second = runtime.cached(key) {
+      makeCount += 1
+      return CachedBox(2)
+    }
+
+    #expect(makeCount == 1)
+    #expect(first === second)
+    #expect(second.value == 1)
+  }
+
+  @Test
+  func `keys are independent`() {
+    let firstKey = JavaScriptRuntime.Cache.Key<CachedBox>()
+    let secondKey = JavaScriptRuntime.Cache.Key<CachedBox>()
+
+    #expect(runtime.cached(firstKey) { CachedBox(1) }.value == 1)
+    #expect(runtime.cached(secondKey) { CachedBox(2) }.value == 2)
+    #expect(runtime.cached(firstKey) { CachedBox(3) }.value == 1)
+  }
+
+  @Test
+  func `keys can be used in any order`() {
+    let keys = (0..<16).map { _ in JavaScriptRuntime.Cache.Key<CachedBox>() }
+
+    // Using the last key first grows the storage past all the others, which must then stay empty.
+    #expect(runtime.cached(keys[15]) { CachedBox(15) }.value == 15)
+    #expect(runtime.cached(keys[3]) { CachedBox(3) }.value == 3)
+    #expect(runtime.cached(keys[15]) { CachedBox(-1) }.value == 15)
+    #expect(runtime.cached(keys[0]) { CachedBox(0) }.value == 0)
+  }
+
+  @Test
+  func `each runtime has its own entries`() {
+    let key = JavaScriptRuntime.Cache.Key<CachedBox>()
+    let otherRuntime = JavaScriptRuntime()
+
+    #expect(runtime.cached(key) { CachedBox(1) }.value == 1)
+    #expect(otherRuntime.cached(key) { CachedBox(2) }.value == 2)
+  }
+
+  @Test
+  func `a value can be created from other cached values`() {
+    let baseKey = JavaScriptRuntime.Cache.Key<CachedBox>()
+    let derivedKey = JavaScriptRuntime.Cache.Key<CachedBox>()
+
+    // The nested lookup runs while the outer one is still creating its value.
+    let derived = runtime.cached(derivedKey) {
+      let base = runtime.cached(baseKey) { CachedBox(20) }
+      return CachedBox(base.value + 1)
+    }
+
+    #expect(derived.value == 21)
+    #expect(runtime.cached(baseKey) { CachedBox(0) }.value == 20)
+  }
+
+  @Test
+  func `a throwing make caches nothing`() throws {
+    struct MakeError: Error {}
+    let key = JavaScriptRuntime.Cache.Key<CachedBox>()
+
+    #expect(throws: MakeError.self) {
+      try runtime.cached(key) { throw MakeError() }
+    }
+    #expect(runtime.cached(key) { CachedBox(1) }.value == 1)
+  }
+
+  @Test
+  func `caches JavaScript values`() throws {
+    let key = JavaScriptRuntime.Cache.Key<JavaScriptValue>()
+
+    let first = try runtime.cached(key) { try runtime.eval("({ answer: 42 })") }
+    let second = try runtime.cached(key) { try runtime.eval("({ answer: 0 })") }
+
+    #expect(first === second)
+    #expect(second.getObject().getProperty("answer").getInt() == 42)
+  }
+
+  @Test
+  func `cached values are released with the runtime`() {
+    let key = JavaScriptRuntime.Cache.Key<CachedBox>()
+    weak var cachedValue: CachedBox?
+
+    do {
+      let runtime = JavaScriptRuntime()
+      cachedValue = runtime.cached(key) { CachedBox(1) }
+      #expect(cachedValue != nil)
+      withExtendedLifetime(runtime) {}
+    }
+
+    #expect(cachedValue == nil)
+  }
+}

package/apple/Tests/JavaScriptRuntimeTests.swift

@@ -34,6 +34,40 @@ struct JavaScriptRuntimeTests {
     #expect(fn.asValue().isFunction() == true)
   }
 
+  @Test
+  func `host function returns a fresh string`() throws {
+    let fn = runtime.createFunction("greet") { [runtime] _, _ in
+      return JavaScriptValue(runtime, "hello")
+    }
+    runtime.global().setProperty("greet", value: fn)
+    #expect(try runtime.eval("greet() + ' ' + greet()").getString() == "hello hello")
+  }
+
+  @Test
+  func `host function returns a shared value repeatedly`() throws {
+    // The same instance is returned on every call, so the host call must copy the engine handle
+    // instead of moving it out: the captured value has to stay valid for the next call.
+    let shared = JavaScriptValue(runtime, "shared")
+    let fn = runtime.createFunction("shared") { _, _ in
+      return shared
+    }
+    runtime.global().setProperty("shared", value: fn)
+    #expect(try runtime.eval("shared() + ' ' + shared()").getString() == "shared shared")
+    #expect(shared.getString() == "shared")
+  }
+
+  @Test
+  func `host function returns an object it keeps`() throws {
+    let kept = runtime.createObject()
+    kept.setProperty("answer", value: 42)
+    let fn = runtime.createFunction("kept") { _, _ in
+      return kept.asValue()
+    }
+    runtime.global().setProperty("kept", value: fn)
+    #expect(try runtime.eval("kept().answer + kept().answer").getInt() == 84)
+    #expect(kept.getProperty("answer").getInt() == 42)
+  }
+
   @Test
   func `evaluate script`() throws {
     #expect(try runtime.eval("'hello' + ' ' + 'world'").getString() == "hello world")
@@ -217,6 +251,31 @@ struct JavaScriptRuntimeTests {
     #expect(hostObject.getProperty("unknown").isUndefined())
   }
 
+  @Test
+  func `host object getter returns strings`() throws {
+    // `fresh` is created per access and gets moved into the result; `shared` is the same instance on
+    // every access and has to be copied so it stays valid.
+    let shared = JavaScriptValue(runtime, "shared")
+    let hostObject = runtime.createHostObject(
+      get: { [runtime] name in
+        switch name {
+        case "fresh":
+          return JavaScriptValue(runtime, "fresh")
+        case "shared":
+          return shared
+        default:
+          return .undefined
+        }
+      },
+      getPropertyNames: { ["fresh", "shared"] }
+    )
+    runtime.global().setProperty("host", value: hostObject)
+
+    #expect(try runtime.eval("host.fresh + host.fresh").getString() == "freshfresh")
+    #expect(try runtime.eval("host.shared + host.shared").getString() == "sharedshared")
+    #expect(shared.getString() == "shared")
+  }
+
   @Test
   func `host object set property`() {
     var storedValue: Int?

package/apple/Tests/JavaScriptUnownedDecodeTests.swift

@@ -0,0 +1,99 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Foundation
+import Testing
+
+/// Decodes through the `JavaScriptUnownedValue` overloads, and through `withUnownedValue(in:_:)` from an
+/// owning value.
+@Suite("JavaScriptDecodable unowned decode")
+@JavaScriptActor
+struct JavaScriptUnownedDecodeTests {
+  let runtime = JavaScriptRuntime()
+
+  private func unowned<T: JavaScriptDecodable>(_ type: T.Type, from source: String) throws -> T {
+    let value = try runtime.eval(source)
+    let buffer = JavaScriptValuesBuffer.allocate(in: runtime, with: value)
+    return try T.decode(buffer.unownedValue(at: 0), in: runtime)
+  }
+
+  // MARK: - withUnownedValue
+
+  @Test
+  func `withUnownedValue borrows the value it is called on`() throws {
+    let number = try runtime.eval("42")
+    #expect(number.withUnownedValue(in: runtime) { $0.getDouble() } == 42)
+
+    let string = try runtime.eval("'text'")
+    #expect(string.withUnownedValue(in: runtime) { $0.getString() } == "text")
+
+    let object = try runtime.eval("({ answer: 42 })")
+    let answer = try object.withUnownedValue(in: runtime) { try $0.asObject(in: runtime).getProperty("answer").asInt() }
+    #expect(answer == 42)
+  }
+
+  @Test
+  func `withUnownedValue works for a value without a runtime`() {
+    let value = JavaScriptValue.number(1.5)
+    #expect(value.withUnownedValue(in: runtime) { $0.getDouble() } == 1.5)
+  }
+
+  // MARK: - Default owning decode
+
+  @Test
+  func `a type that only decodes unowned values also decodes owning ones`() throws {
+    let value = try runtime.eval("7")
+    #expect(try UnownedOnly.decode(value, in: runtime) == UnownedOnly(number: 7))
+  }
+
+  // MARK: - Containers
+
+  @Test
+  func `Array decodes an array and arrayizes a scalar`() throws {
+    #expect(try unowned([Int].self, from: "[1, 2, 3]") == [1, 2, 3])
+    #expect(try unowned([Int].self, from: "4") == [4])
+  }
+
+  @Test
+  func `Dictionary decodes an object and skips undefined properties`() throws {
+    #expect(try unowned([String: Int].self, from: "({ a: 1, b: undefined })") == ["a": 1])
+    #expect(throws: (any Error).self) {
+      _ = try unowned([String: Int].self, from: "42")
+    }
+  }
+
+  @Test
+  func `Date decodes a number, a string and a Date`() throws {
+    #expect(try unowned(Date.self, from: "1000") == Date(timeIntervalSince1970: 1))
+    #expect(try unowned(Date.self, from: "'1970-01-01T00:00:02Z'") == Date(timeIntervalSince1970: 2))
+    #expect(try unowned(Date.self, from: "new Date(3000)") == Date(timeIntervalSince1970: 3))
+    #expect(throws: (any Error).self) {
+      _ = try unowned(Date.self, from: "true")
+    }
+    #expect(throws: (any Error).self) {
+      _ = try unowned(Date.self, from: "({ getTime() { return 0 } })")
+    }
+    #expect(throws: (any Error).self) {
+      _ = try unowned(Date.self, from: "'not a date'")
+    }
+  }
+
+  @Test
+  func `Date decodes the same from an owning value`() throws {
+    #expect(try Date.decode(runtime.eval("1000"), in: runtime) == Date(timeIntervalSince1970: 1))
+    #expect(try Date.decode(runtime.eval("'1970-01-01T00:00:02Z'"), in: runtime) == Date(timeIntervalSince1970: 2))
+    #expect(try Date.decode(runtime.eval("new Date(3000)"), in: runtime) == Date(timeIntervalSince1970: 3))
+  }
+}
+
+/// Implements only the unowned decode, so its owning decode is the protocol default.
+private struct UnownedOnly: JavaScriptDecodable, Equatable {
+  let number: Double
+
+  @JavaScriptActor
+  static func decode(_ value: borrowing JavaScriptUnownedValue, in runtime: borrowing JavaScriptRuntime) throws
+    -> UnownedOnly
+  {
+    return UnownedOnly(number: try value.asDouble())
+  }
+}

package/apple/Tests/JavaScriptUnownedElementsTests.swift

@@ -0,0 +1,76 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesJSI
+import Testing
+
+/// Lending array elements and object properties out as `JavaScriptUnownedValue`s.
+@Suite("Unowned elements and properties")
+@JavaScriptActor
+struct JavaScriptUnownedElementsTests {
+  let runtime = JavaScriptRuntime()
+
+  @Test
+  func `mapUnowned transforms every element in order`() throws {
+    let array = try runtime.eval("[1, 'two', null, { four: 4 }]").getArray()
+    let kinds = array.mapUnowned { element -> String in
+      if element.isNumber() {
+        return "number \(element.getDouble())"
+      }
+      if element.isString() {
+        return "string \(element.getString())"
+      }
+      if element.isNull() {
+        return "null"
+      }
+      return "object"
+    }
+    #expect(kinds == ["number 1.0", "string two", "null", "object"])
+  }
+
+  @Test
+  func `mapUnowned of an empty array is empty`() throws {
+    let array = try runtime.eval("[]").getArray()
+    #expect(array.mapUnowned { $0.isNumber() }.isEmpty)
+  }
+
+  @Test
+  func `mapUnowned rethrows the transform's error`() throws {
+    let array = try runtime.eval("[1, 'two']").getArray()
+    #expect(throws: (any Error).self) {
+      _ = try array.mapUnowned { try $0.asDouble() }
+    }
+  }
+
+  @Test
+  func `withUnownedProperty lends the property and undefined for a missing one`() throws {
+    let object = try runtime.eval("({ answer: 42, name: 'expo' })").getObject()
+    #expect(object.withUnownedProperty("answer") { $0.getDouble() } == 42)
+    #expect(object.withUnownedProperty("name") { $0.getString() } == "expo")
+    #expect(object.withUnownedProperty("missing") { $0.isUndefined() })
+  }
+
+  @Test
+  func `containers decode nested values through the unowned path`() throws {
+    let value = try runtime.eval("[[1, 2], [3]]")
+    #expect(try [[Int]].decode(value, in: runtime) == [[1, 2], [3]])
+    let dictionary = try runtime.eval("({ a: [1], b: undefined, c: [2, 3] })")
+    #expect(try [String: [Int]].decode(dictionary, in: runtime) == ["a": [1], "c": [2, 3]])
+  }
+
+  @Test
+  func `an unowned value tells arrays apart and reads them`() throws {
+    let buffer = JavaScriptValuesBuffer.allocate(
+      in: runtime,
+      with: try runtime.eval("[1, 2, 3]"),
+      try runtime.eval("({ length: 3 })"),
+      try runtime.eval("new Uint8Array(3)"),
+      try runtime.eval("3")
+    )
+    // `#expect` can't capture the `~Copyable` value, so compare the results instead.
+    let isArray = (0..<4).map { buffer.unownedValue(at: $0).isArray() }
+    #expect(isArray == [true, false, false, false])
+    let array = buffer.unownedValue(at: 0).getArray(in: runtime)
+    #expect(array.length == 3)
+    #expect(array.mapUnowned { $0.getDouble() } == [1, 2, 3])
+  }
+}

package/apple/scripts/build-xcframework.sh

@@ -208,6 +208,18 @@ build_slice() {
   # `___profc_*` symbols and `__llvm_prf_*` sections) plus ~40% extra binary size. Setting
   # CLANG_COVERAGE_MAPPING=NO is what removes the flags; CLANG_ENABLE_CODE_COVERAGE=NO alone
   # does not, and `-enableCodeCoverage NO` is rejected outside of `test`.
+  #
+  # With a dSYM, Xcode's default STRIP_SWIFT_SYMBOLS=YES runs `strip -T`, which removes or renames to
+  # `<redacted>` every Swift symbol that isn't exported. Crash reports symbolicated on the device then
+  # show no function name for any frame in this framework. Keeping the symbols adds about 250 KB of
+  # symbol table to the device slice; the code itself doesn't change.
+  #
+  # The binary .swiftmodule must not embed this checkout's absolute paths: consumers key
+  # the Xcode compilation cache on its content, so any PACKAGE_DIR or PODS_ROOT path inside
+  # it makes every module that imports ExpoModulesJSI a cache miss in another checkout or
+  # worktree. SWIFT_SERIALIZE_DEBUGGING_OPTIONS=NO drops the serialized search paths and
+  # SWIFT_ENABLE_EXPLICIT_MODULES=NO the explicit-module cache directories under
+  # .DerivedData. The .swiftinterface and the dSYM are unaffected.
   (cd "$PACKAGE_DIR" && env -i PATH="$PATH" HOME="$HOME" PODS_ROOT="$PODS_ROOT" RN_ROOT="$RN_ROOT" \
     xcodebuild \
     build \
@@ -226,10 +238,13 @@ build_slice() {
     BUILD_LIBRARY_FOR_DISTRIBUTION=YES \
     SKIP_INSTALL=NO \
     DEBUG_INFORMATION_FORMAT=dwarf-with-dsym \
+    STRIP_SWIFT_SYMBOLS=NO \
     COMPILER_INDEX_STORE_ENABLE=NO \
     SWIFT_COMPILATION_MODE=wholemodule \
     CLANG_ENABLE_CODE_COVERAGE=NO \
     CLANG_COVERAGE_MAPPING=NO \
+    SWIFT_SERIALIZE_DEBUGGING_OPTIONS=NO \
+    SWIFT_ENABLE_EXPLICIT_MODULES=NO \
   )
 
   local product_path="${BUILD_PRODUCTS_PATH}/${build_dir_name}"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-jsi",
-  "version": "58.0.7",
+  "version": "58.0.8",
   "description": "The JavaScript Interface for Expo Modules",
   "main": "index.js",
   "sideEffects": [],