expo-modules-jsi 58.0.7 → 58.0.9

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.9",
   "description": "The JavaScript Interface for Expo Modules",
   "main": "index.js",
   "sideEffects": [],