expo-modules-macros 0.17.0-0 → 0.17.0

package/apple/Sources/ExpoModulesMacros/DecorateModuleBuilder.swift

@@ -154,7 +154,7 @@ internal struct JSFunction {
       lines.append(contentsOf: encodeResultLines().map { "  " + $0 })
     } else {
       lines.append("  \(callExpression(receiver: receiver, arity: arity))")
-      lines.append("  return .undefined")
+      lines.append("  return .undefined()")
     }
     lines.append("}")
     return lines
@@ -204,7 +204,7 @@ internal struct JSFunction {
 
   /// The flat (single-arity) call-and-encode lines used when no trailing parameter is omittable:
   /// `let result = <callee>.f(...)` then the return encode (or the no-return `<callee>.f(...)` +
-  /// `.undefined`).
+  /// `.undefined()`).
   private func callAndEncodeLines(receiver: Receiver, arity: Int, decodingFrom: Int) -> [String] {
     var lines: [String] = []
     for index in decodingFrom..<arity {
@@ -215,7 +215,7 @@ internal struct JSFunction {
       lines.append(contentsOf: encodeResultLines())
     } else {
       lines.append(callExpression(receiver: receiver, arity: arity))
-      lines.append("return .undefined")
+      lines.append("return .undefined()")
     }
     return lines
   }
@@ -225,7 +225,7 @@ internal struct JSFunction {
   /// value as the primitive's `toJavaScriptValue(in:)` except for `Int`/`UInt`, where it range-checks
   /// and throws instead of silently encoding an out-of-safe-range value as a lossy number — the
   /// catchable error is the right behavior, and matches how non-primitive integers already encode. A
-  /// no-return function returns `.undefined` instead.
+  /// no-return function returns `.undefined()` instead.
   ///
   /// For an `async` function the encode must run on the JS thread. An `async` body may suspend and
   /// resume on an arbitrary cooperative-pool thread, and encoding a heap-allocated JS value (a string,
@@ -235,7 +235,7 @@ internal struct JSFunction {
   /// which always run on the JS thread — keep encoding directly without the wrapper.
   private func encodeResultLines() -> [String] {
     guard let returnType else {
-      return ["return .undefined"]
+      return ["return .undefined()"]
     }
     let encode = "try \(expressionType(returnType)).encode(result, in: runtime)"
     if isAsync {
@@ -340,7 +340,7 @@ internal struct JSProperty {
       let setDecode = "\(callee).\(swiftName) = try \(decodeCall(valueType, from: "arguments.unownedValue(at: 0)"))"
       lines.append(
         accessorClosure(
-          descriptorName, "set", receiver: receiver, body: "\(unwrap)\(setDecode)\nreturn .undefined"))
+          descriptorName, "set", receiver: receiver, body: "\(unwrap)\(setDecode)\nreturn .undefined()"))
     }
 
     lines.append("\(object).defineProperty(\"\(jsName)\", descriptor: \(descriptorName))")
@@ -437,7 +437,7 @@ internal func buildDecorateSharedObjectPhase(
 }
 
 /// True when a return clause is absent or written as `Void` / `()` — i.e. the function returns
-/// nothing JS-visible, so the binding returns `.undefined`.
+/// nothing JS-visible, so the binding returns `.undefined()`.
 private func isVoidType(_ type: TypeSyntax?) -> Bool {
   guard let type else {
     return true

package/apple/Sources/ExpoModulesMacros/FreeFormTypes.swift

@@ -30,13 +30,16 @@ private let freeFormDecodeMethods: [String: String] = [
   "[String:Any]": "decodeAnyDictionary",
 ]
 
-/// The type-safe alternative a free-form type's diagnostic steers to: the same shape with the `Any`
-/// element replaced by `JavaScriptValue`, which conforms to the codable protocols. Keyed by the
-/// free-form type's normalized spelling; spelled with conventional spacing for the message.
+/// The type-safe alternative a free-form type's diagnostic steers to: the JS wrapper of the same shape
+/// (`JavaScriptArray` for an array, `JavaScriptObject` for a dictionary, `JavaScriptValue` for an
+/// untyped value). The wrappers conform to the codable protocols and keep the value unconverted; a
+/// non-copyable `JavaScriptValue` cannot be an element of a Swift array or dictionary, so the container
+/// shapes map to a wrapper rather than to a container of values. Keyed by the free-form type's
+/// normalized spelling.
 private let typedFreeFormReplacements: [String: String] = [
   "Any": "JavaScriptValue",
-  "[Any]": "[JavaScriptValue]",
-  "[String:Any]": "[String: JavaScriptValue]",
+  "[Any]": "JavaScriptArray",
+  "[String:Any]": "JavaScriptObject",
 ]
 
 /// True when a boundary type (as written) is one of the free-form spellings, ignoring internal
@@ -54,8 +57,8 @@ internal func freeFormDecodeMethod(for type: String) -> String? {
   return freeFormDecodeMethods[normalizedTypeSpelling(type)]
 }
 
-/// The type-safe alternative to suggest in place of a free-form type (its `Any` element replaced by
-/// `JavaScriptValue`), or `nil` when the type isn't free-form.
+/// The type-safe alternative to suggest in place of a free-form type (the JS wrapper of the same shape),
+/// or `nil` when the type isn't free-form.
 internal func typedFreeFormReplacement(for type: String) -> String? {
   return typedFreeFormReplacements[normalizedTypeSpelling(type)]
 }

package/apple/Sources/ExpoModulesMacros/JSConstructor.swift

@@ -51,7 +51,7 @@ internal struct JSConstructor {
   func buildConstructor(typeName: String) -> DeclSyntax {
     return """
       @JavaScriptActor
-      public override class func _constructSharedObject(this: JavaScriptValue, arguments: borrowing JavaScriptValuesBuffer, in runtime: JavaScriptRuntime) throws -> SharedObject? {
+      public override class func _constructSharedObject(this: borrowing JavaScriptValue, arguments: borrowing JavaScriptValuesBuffer, in runtime: JavaScriptRuntime) throws -> SharedObject? {
       \(raw: bodyStatements(typeName: typeName, indent: "  "))
       }
       """

package/apple/Sources/ExpoModulesMacros/JSMacro.swift

@@ -120,7 +120,7 @@ private func insertAsyncFixIt(for funcDecl: FunctionDeclSyntax) -> FixIt {
 /// `JavaScriptValue.decodeAny…`; there is no free-form encode, so any position that encodes is a hard
 /// error. That means:
 /// - a function/constructor **parameter** typed free-form gets a warning steering to
-///   `[String: JavaScriptValue]` (the type-safe alternative), but compiles;
+///   `JavaScriptValue` (the type-safe alternative), but compiles;
 /// - a function **return** typed free-form is an error (it would need to encode);
 /// - a **property** typed free-form is an error regardless of settability, because its getter always
 ///   encodes.
@@ -156,9 +156,8 @@ private func diagnoseFreeFormTypes(
   }
 }
 
-/// The tail of a free-form encode error: the reshaped `JavaScriptValue` alternative when the type is a
-/// container (`[String: Any]` -> `[String: JavaScriptValue]`), otherwise the passthrough suggestion
-/// for a bare `Any`. Both conform to the codable protocols, so either is a valid fix.
+/// The tail of a free-form encode error: the typed wrapper of the same shape (`JavaScriptArray`,
+/// `JavaScriptObject`) when there is one, otherwise the plain `JavaScriptValue` passthrough suggestion.
 private func suggestedAlternative(for freeFormType: String) -> String {
   if let reshaped = typedFreeFormReplacement(for: freeFormType), reshaped != "JavaScriptValue" {
     return "Use '\(reshaped)', or 'JavaScriptValue' to pass a JS value through unchanged."
@@ -189,7 +188,7 @@ private func freeFormArgumentWarning(
   suggesting suggestedType: String
 ) -> JSDiagnosticMessage {
   return JSDiagnosticMessage(
-    "Prefer '\(suggestedType)' over the free-form '\(freeFormType)' for a @JS argument. Free-form decoding boxes every value as 'Any' (slower, no static typing); the 'JavaScriptValue' element keeps each value inspectable without erasing it.",
+    "Prefer '\(suggestedType)' over the free-form '\(freeFormType)' for a @JS argument. Free-form decoding boxes every value as 'Any' (slower, no static typing); '\(suggestedType)' keeps the JS value inspectable without converting it.",
     id: "js-free-form-argument",
     severity: .warning
   )

package/apple/Sources/ExpoModulesMacros/RecordMacro.swift

@@ -529,7 +529,7 @@ private func toObjectMethod(properties: [RecordProperty], inheritsRecord: Bool)
     switch property.freeForm {
     case .shape(_, let encodeMethod, let isOptional, _):
       encode = isOptional
-        ? "self.\(property.name) == nil ? .null : try JavaScriptValue.\(encodeMethod)(self.\(property.name)!, in: runtime)"
+        ? "self.\(property.name) == nil ? .null() : try JavaScriptValue.\(encodeMethod)(self.\(property.name)!, in: runtime)"
         : "try JavaScriptValue.\(encodeMethod)(self.\(property.name), in: runtime)"
     case .generic:
       // The explicit `as Any` keeps an optional property from warning about its implicit coercion.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.17.0-0",
+  "version": "0.17.0",
   "description": "Swift macro plugin for Expo modules",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -23,7 +23,7 @@
     "typescript": "^5.4.0"
   },
   "optionalDependencies": {
-    "@expo/modules-macros-win32-arm64": "0.17.0-0",
-    "@expo/modules-macros-win32-x64": "0.17.0-0"
+    "@expo/modules-macros-win32-arm64": "0.17.0",
+    "@expo/modules-macros-win32-x64": "0.17.0"
   }
 }