@capacitor/ios 6.0.0-alpha.2 → 6.0.0-beta.1

package/Capacitor/Capacitor/CAPInstanceDescriptor.swift

@@ -33,7 +33,7 @@ internal extension InstanceDescriptor {
         // sanity check that the app directory is valid
         var isDirectory: ObjCBool = ObjCBool(false)
         if warnings.contains(.missingAppDir) == false,
-           (FileManager.default.fileExists(atPath: appLocation.path, isDirectory: &isDirectory) == false || isDirectory.boolValue == false) {
+           FileManager.default.fileExists(atPath: appLocation.path, isDirectory: &isDirectory) == false || isDirectory.boolValue == false {
             warnings.update(with: .missingAppDir)
         }
 

package/Capacitor/Capacitor/CAPPluginCall.swift

@@ -77,3 +77,29 @@ extension CAPPluginCall: JSValueContainer {
         errorHandler(CAPPluginCallError(message: message, code: "UNAVAILABLE", error: nil, data: [:]))
     }
 }
+
+// MARK: Codable Support
+public extension CAPPluginCall {
+    /// Encodes the given value to a ``JSObject`` and resolves the call.
+    /// - Parameters:
+    ///  - data: The value to encode.
+    ///  - encoder: The encoder to use. Defaults to `JSValueEncoder()`.
+    /// - Throws: If the value cannot be encoded.
+    ///
+    /// The data paramater _must_ be encodable as a
+    /// ``JSObject``, otherwise this method will throw.
+    func resolve<T: Encodable>(with data: T, encoder: JSValueEncoder = JSValueEncoder()) throws {
+        let encoded = try encoder.encodeJSObject(data)
+        resolve(encoded)
+    }
+
+    /// Decodes the options to the given type.
+    /// - Parameters:
+    ///   - type: The type to decode to.
+    ///   - decoder: The decoder to use. Defaults to `JSValueDecoder()`.
+    /// - Throws: If the options cannot be decoded.
+    /// - Returns: The decoded value.
+    func decode<T: Decodable>(_ type: T.Type, decoder: JSValueDecoder = JSValueDecoder()) throws -> T {
+        try decoder.decode(type, from: options as? JSObject ?? [:])
+    }
+}

package/Capacitor/Capacitor/Codable/JSValueDecoder.swift

@@ -0,0 +1,320 @@
+//
+//  JSValueDecoder.swift
+//  Capacitor
+//
+//  Created by Steven Sherry on 12/8/23.
+//  Copyright © 2023 Drifty Co. All rights reserved.
+//
+
+import Foundation
+import Combine
+
+/// A decoder that can decode ``JSValue`` objects into `Decodable` types.
+public final class JSValueDecoder: TopLevelDecoder {
+    public init() {}
+
+    /// Decodes a ``JSValue`` into the provided `Decodable` type
+    /// - Parameters:
+    ///   - type: The type of the value to decode from the provided ``JSValue`` object
+    ///   - data: The ``JSValue`` to decode
+    /// - Returns: A value of the specified type.
+    ///
+    /// An error will be thrown from this method for two possible reasons:
+    /// 1. A type mismatch was found.
+    /// 2. A key was not found in the `data` field that is required in the `type` provided.
+    public func decode<T>(_ type: T.Type, from data: JSValue) throws -> T where T: Decodable {
+        let decoder = _JSValueDecoder(data: data)
+        return try T(from: decoder)
+    }
+}
+
+typealias CodingUserInfo = [CodingUserInfoKey: Any]
+
+private final class _JSValueDecoder {
+    internal var codingPath: [CodingKey] = []
+    internal var userInfo: CodingUserInfo = [:]
+    fileprivate var data: JSValue
+
+    init(data: JSValue) {
+        self.data = data
+    }
+}
+
+extension _JSValueDecoder: Decoder {
+    func container<Key>(keyedBy type: Key.Type) throws -> KeyedDecodingContainer<Key> where Key: CodingKey {
+        guard let data = data as? JSObject else {
+            throw DecodingError.typeMismatch(JSObject.self, on: data, codingPath: codingPath)
+        }
+
+        return KeyedDecodingContainer(
+            KeyedContainer(
+                data: data,
+                codingPath: codingPath,
+                userInfo: userInfo
+            )
+        )
+    }
+
+    func unkeyedContainer() throws -> UnkeyedDecodingContainer {
+        guard let data = data as? JSArray else {
+            throw DecodingError.typeMismatch(JSArray.self, on: data, codingPath: codingPath)
+        }
+
+        return UnkeyedContainer(data: data, codingPath: codingPath, userInfo: userInfo)
+    }
+
+    func singleValueContainer() throws -> SingleValueDecodingContainer {
+        SingleValueContainer(data: data, codingPath: codingPath, userInfo: userInfo)
+    }
+}
+
+private final class KeyedContainer<Key> where Key: CodingKey {
+    var data: JSObject
+    var codingPath: [CodingKey]
+    var userInfo: CodingUserInfo
+    var allKeys: [Key]
+
+    init(data: JSObject, codingPath: [CodingKey], userInfo: CodingUserInfo) {
+        self.data = data
+        self.codingPath = codingPath
+        self.userInfo = userInfo
+        self.allKeys = data.keys.compactMap(Key.init(stringValue:))
+    }
+}
+
+extension KeyedContainer: KeyedDecodingContainerProtocol {
+    func contains(_ key: Key) -> Bool {
+        allKeys.contains { $0.stringValue == key.stringValue }
+    }
+
+    func decodeNil(forKey key: Key) throws -> Bool {
+        data[key.stringValue] == nil || data[key.stringValue] is NSNull
+    }
+
+    func decode<T>(_ type: T.Type, forKey key: Key) throws -> T where T: Decodable {
+        guard let rawValue = data[key.stringValue] else {
+            throw DecodingError.keyNotFound(key, on: data, codingPath: codingPath)
+        }
+
+        var newPath = codingPath
+        newPath.append(key)
+        let decoder = _JSValueDecoder(data: rawValue)
+        return try T(from: decoder)
+    }
+
+    func nestedUnkeyedContainer(forKey key: Key) throws -> UnkeyedDecodingContainer {
+        var newPath = codingPath
+        newPath.append(key)
+        guard let data = data[key.stringValue] as? JSArray else {
+            throw DecodingError.typeMismatch(
+                JSArray.self,
+                on: data[key.stringValue] ?? "null value",
+                codingPath: newPath
+            )
+        }
+
+        return UnkeyedContainer(data: data, codingPath: newPath, userInfo: userInfo)
+    }
+
+    func nestedContainer<NestedKey>(keyedBy type: NestedKey.Type, forKey key: Key) throws -> KeyedDecodingContainer<NestedKey> where NestedKey: CodingKey {
+        var newPath = codingPath
+        newPath.append(key)
+        guard let data = data[key.stringValue] as? JSObject else {
+            throw DecodingError.typeMismatch(
+                JSObject.self,
+                on: data[key.stringValue] ?? "null value",
+                codingPath: newPath
+            )
+        }
+
+        return KeyedDecodingContainer(KeyedContainer<NestedKey>(data: data, codingPath: newPath, userInfo: userInfo))
+    }
+
+    enum SuperKey: String, CodingKey { case `super` }
+
+    func superDecoder() throws -> Decoder {
+        var newPath = codingPath
+        newPath.append(SuperKey.super)
+        guard let data = data[SuperKey.super.stringValue] else {
+            throw DecodingError.keyNotFound(SuperKey.super, on: data, codingPath: newPath)
+        }
+
+        return _JSValueDecoder(data: data)
+    }
+
+    func superDecoder(forKey key: Key) throws -> Decoder {
+        var newPath = codingPath
+        newPath.append(key)
+        guard let data = data[key.stringValue] else {
+            throw DecodingError.keyNotFound(key, on: data, codingPath: newPath)
+        }
+
+        return _JSValueDecoder(data: data)
+    }
+}
+
+private final class UnkeyedContainer {
+    var data: JSArray
+    var codingPath: [CodingKey]
+    var userInfo: CodingUserInfo
+    private(set) var currentIndex = 0
+
+    init(data: JSArray, codingPath: [CodingKey], userInfo: CodingUserInfo) {
+        self.data = data
+        self.codingPath = codingPath
+        self.userInfo = userInfo
+    }
+}
+
+extension UnkeyedContainer: UnkeyedDecodingContainer {
+    var count: Int? {
+        data.count
+    }
+
+    var isAtEnd: Bool {
+        currentIndex == data.endIndex
+    }
+
+    func decodeNil() throws -> Bool {
+        defer { currentIndex += 1 }
+        return data[currentIndex] is NSNull
+    }
+
+    func decode<T>(_ type: T.Type) throws -> T where T: Decodable {
+        defer { currentIndex += 1 }
+        let decoder = _JSValueDecoder(data: data[currentIndex])
+        return try T(from: decoder)
+    }
+
+    func nestedUnkeyedContainer() throws -> UnkeyedDecodingContainer {
+        defer { currentIndex += 1 }
+        guard let data = data[currentIndex] as? JSArray else {
+            throw DecodingError.typeMismatch(JSArray.self, on: data[currentIndex], codingPath: codingPath)
+        }
+
+        return UnkeyedContainer(data: data, codingPath: codingPath, userInfo: userInfo)
+    }
+
+    func nestedContainer<NestedKey>(keyedBy type: NestedKey.Type) throws -> KeyedDecodingContainer<NestedKey> where NestedKey: CodingKey {
+        defer { currentIndex += 1 }
+        guard let data = data[currentIndex] as? JSObject else {
+            throw DecodingError.typeMismatch(JSObject.self, on: data[currentIndex], codingPath: codingPath)
+        }
+
+        return KeyedDecodingContainer(KeyedContainer(data: data, codingPath: codingPath, userInfo: userInfo))
+    }
+
+    func superDecoder() throws -> Decoder {
+        defer { currentIndex += 1 }
+        let data = data[currentIndex]
+        return _JSValueDecoder(data: data)
+    }
+}
+
+private final class SingleValueContainer {
+    var data: JSValue
+    var codingPath: [CodingKey]
+    var userInfo: CodingUserInfo
+
+    init(data: JSValue, codingPath: [CodingKey], userInfo: CodingUserInfo) {
+        self.data = data
+        self.codingPath = codingPath
+        self.userInfo = userInfo
+    }
+}
+
+extension SingleValueContainer: SingleValueDecodingContainer {
+    func decodeNil() -> Bool {
+        return data is NSNull
+    }
+
+    private func cast<T>(to type: T.Type) throws -> T {
+        guard let data = data as? T else {
+            throw DecodingError.typeMismatch(type, on: data, codingPath: codingPath)
+        }
+
+        return data
+    }
+
+    func decode(_ type: Bool.Type) throws -> Bool {
+        try cast(to: type)
+    }
+
+    func decode(_ type: String.Type) throws -> String {
+        try cast(to: type)
+    }
+
+    func decode(_ type: Double.Type) throws -> Double {
+        try cast(to: type)
+    }
+
+    func decode(_ type: Float.Type) throws -> Float {
+        try cast(to: type)
+    }
+
+    func decode(_ type: Int.Type) throws -> Int {
+        try cast(to: type)
+    }
+
+    func decode(_ type: Int8.Type) throws -> Int8 {
+        try cast(to: type)
+    }
+
+    func decode(_ type: Int16.Type) throws -> Int16 {
+        try cast(to: type)
+    }
+
+    func decode(_ type: Int32.Type) throws -> Int32 {
+        try cast(to: type)
+    }
+
+    func decode(_ type: Int64.Type) throws -> Int64 {
+        try cast(to: type)
+    }
+
+    func decode(_ type: UInt.Type) throws -> UInt {
+        try cast(to: type)
+    }
+
+    func decode(_ type: UInt8.Type) throws -> UInt8 {
+        try cast(to: type)
+    }
+
+    func decode(_ type: UInt16.Type) throws -> UInt16 {
+        try cast(to: type)
+    }
+
+    func decode(_ type: UInt32.Type) throws -> UInt32 {
+        try cast(to: type)
+    }
+
+    func decode(_ type: UInt64.Type) throws -> UInt64 {
+        try cast(to: type)
+    }
+
+    func decode<T>(_ type: T.Type) throws -> T where T: Decodable {
+        let decoder = _JSValueDecoder(data: data)
+        return try T(from: decoder)
+    }
+}
+
+extension DecodingError {
+    static func typeMismatch(_ type: Any.Type, on data: JSValue, codingPath: [CodingKey]) -> DecodingError {
+        return .typeMismatch(
+            type,
+            .init(
+                codingPath: codingPath,
+                debugDescription: "\(data) was unable to be cast to \(type)."
+            )
+        )
+    }
+
+    static func keyNotFound(_ key: any CodingKey, on data: JSValue, codingPath: [CodingKey]) -> DecodingError {
+        return .keyNotFound(
+            key,
+            .init(
+                codingPath: codingPath,
+                debugDescription: "Key \(key.stringValue) not found in \(data)")
+        )
+    }
+}

package/Capacitor/Capacitor/Codable/JSValueEncoder.swift

@@ -0,0 +1,541 @@
+//
+//  JSValueEncoder.swift
+//  Capacitor
+//
+//  Created by Steven Sherry on 12/8/23.
+//  Copyright © 2023 Drifty Co. All rights reserved.
+//
+
+import Foundation
+import Combine
+
+/// An encoder than can encode ``JSValue`` objects from `Encodable` types
+public final class JSValueEncoder: TopLevelEncoder {
+    /// The strategy to use when encoding `nil` values
+    public enum OptionalEncodingStrategy {
+        /// Encode `nil` values as `NSNull`
+        case explicitNulls
+        /// Excludes the value from the encoded object altogether
+        case undefined
+    }
+
+    /// The strategy to use when encoding `nil` values
+    public var optionalEncodingStrategy: OptionalEncodingStrategy
+
+    /// Creates a new `JSValueEncoder`
+    /// - Parameter optionalEncodingStrategy: The strategy to use when encoding `nil` values
+    public init(optionalEncodingStrategy: OptionalEncodingStrategy = .undefined) {
+        self.optionalEncodingStrategy = optionalEncodingStrategy
+    }
+
+    /// Encodes an `Encodable` value to a ``JSValue``
+    /// - Parameter value: The value to encode to ``JSValue``
+    /// - Returns: The encoded ``JSValue``
+    /// - Throws: An error if the value could not be encoded as a ``JSValue``
+    public func encode<T>(_ value: T) throws -> JSValue where T: Encodable {
+        let encoder = _JSValueEncoder(optionalEncodingStrategy: optionalEncodingStrategy)
+        try value.encode(to: encoder)
+        guard let value = encoder.data else {
+            throw EncodingError.invalidValue(
+                value,
+                .init(
+                    codingPath: encoder.codingPath,
+                    debugDescription: "\(value) was unable to be encoded as a JSValue"
+                )
+            )
+        }
+
+        return value
+    }
+
+    /// Encodes an `Encodable` value to a ``JSObject``
+    /// - Parameter value: The value to encode to a ``JSObject``
+    /// - Returns: The encoded ``JSObject``
+    /// - Throws: An error if the value could not be encoded as a ``JSObject``
+    ///
+    /// This method is a convenience method for encoding an `Encodable` value to a ``JSObject``.
+    /// It is equivalent to calling ``encode(_:)`` and casting the result to a ``JSObject`` and
+    /// throwing an error if the cast fails.
+    public func encodeJSObject<T>(_ value: T) throws -> JSObject where T: Encodable {
+        guard let object = try encode(value) as? JSObject else {
+            throw EncodingError.invalidValue(
+                value,
+                .init(
+                    codingPath: [],
+                    debugDescription: "\(value) was unable to be encoded as a JSObject"
+                )
+            )
+        }
+
+        return object
+    }
+}
+
+private protocol JSValueEncodingContainer {
+    var data: JSValue? { get }
+}
+
+private enum EncodingContainer: JSValueEncodingContainer {
+    case singleValue(SingleValueContainer)
+    case unkeyed(UnkeyedContainer)
+    case keyed(AnyKeyedContainer)
+
+    var data: JSValue? {
+        switch self {
+        case let .singleValue(container):
+            return container.data
+        case let .unkeyed(container):
+            return container.data
+        case let .keyed(container):
+            return container.data
+        }
+    }
+
+    var type: String {
+        switch self {
+        case .singleValue:
+            "SingleValueContainer"
+        case .unkeyed:
+            "UnkeyedContainer"
+        case .keyed:
+            "KeyedContainer"
+        }
+    }
+}
+
+private final class _JSValueEncoder: JSValueEncodingContainer {
+    var codingPath: [CodingKey] = []
+    var data: JSValue? {
+        containers.data
+    }
+
+    let optionalEncodingStrategy: JSValueEncoder.OptionalEncodingStrategy
+
+    var userInfo: CodingUserInfo = [:]
+    fileprivate var containers: [EncodingContainer] = []
+
+    init(optionalEncodingStrategy: JSValueEncoder.OptionalEncodingStrategy) {
+        self.optionalEncodingStrategy = optionalEncodingStrategy
+    }
+}
+
+extension Array: JSValueEncodingContainer where Element == EncodingContainer {
+    var data: JSValue? {
+        guard count != 0 else { return nil }
+        guard count != 1 else { return self[0].data }
+        var data: (any JSValue)? = nil
+
+        for container in self {
+            if data == nil {
+                data = container.data
+            } else {
+                // The top-level container is
+                switch container {
+                case let .keyed(container):
+                    guard let obj = data as? JSObject else { break }
+                    data = obj.merging(container.object() ?? [:]) { $1 }
+                case let .unkeyed(container):
+                    guard var copy = data as? JSArray else { break }
+                    copy.append(contentsOf: container.array ?? [])
+                    data = copy
+                default:
+                    break
+                }
+            }
+        }
+
+        return data
+    }
+}
+
+private enum EncodedValue {
+    case value(any JSValue)
+    case nestedContainer(any JSValueEncodingContainer)
+}
+
+extension _JSValueEncoder: Encoder {
+    func addContainer(_ container: EncodingContainer) {
+        guard !containers.isEmpty else {
+            containers.append(container)
+            return
+        }
+
+        for existingContainer in containers {
+            switch (existingContainer, container) {
+            case (.unkeyed, .unkeyed), (.keyed, .keyed):
+                containers.append(container)
+            default:
+                preconditionFailure("Sibling top-level containers must be of the same type. Attempted to add a \(container)")
+            }
+        }
+    }
+
+    func container<Key>(keyedBy type: Key.Type) -> KeyedEncodingContainer<Key> where Key: CodingKey {
+        let container = KeyedContainer<Key>(codingPath: codingPath, userInfo: userInfo, optionalEncodingStrategy: optionalEncodingStrategy)
+        addContainer(.keyed(.init(container)))
+        return KeyedEncodingContainer(container)
+    }
+
+    func unkeyedContainer() -> UnkeyedEncodingContainer {
+        let container = UnkeyedContainer(codingPath: codingPath, userInfo: userInfo, optionalEncodingStrategy: optionalEncodingStrategy)
+        addContainer(.unkeyed(container))
+        return container
+    }
+
+    func singleValueContainer() -> SingleValueEncodingContainer {
+        let container = SingleValueContainer(codingPath: codingPath, userInfo: userInfo, optionalEncodingStrategy: optionalEncodingStrategy)
+        addContainer(.singleValue(container))
+        return container
+    }
+}
+
+fileprivate final class KeyedContainer<Key> where Key: CodingKey {
+    var object: JSObject? {
+        encodedKeyedValue?.reduce(into: [:]) { obj, next in
+            let (key, value) = next
+            switch value {
+            case .value(let value):
+                obj[key] = value
+            case .nestedContainer(let container):
+                obj[key] = container.data
+            }
+        }
+    }
+
+    var codingPath: [CodingKey]
+    var userInfo: CodingUserInfo
+    var optionalEncodingStrategy: JSValueEncoder.OptionalEncodingStrategy
+    private var encodedKeyedValue: [String: EncodedValue]?
+
+    init(codingPath: [CodingKey], userInfo: CodingUserInfo, optionalEncodingStrategy: JSValueEncoder.OptionalEncodingStrategy) {
+        self.codingPath = codingPath
+        self.userInfo = userInfo
+        self.optionalEncodingStrategy = optionalEncodingStrategy
+    }
+}
+
+extension KeyedContainer: KeyedEncodingContainerProtocol {
+    func insert(_ value: JSValue, for key: Key) {
+        insert(.value(value), for: key)
+    }
+
+    func insert<K: CodingKey>(_ encodedValue: EncodedValue, for key: K) {
+        if encodedKeyedValue == nil {
+            encodedKeyedValue = [key.stringValue: encodedValue]
+        } else {
+            encodedKeyedValue![key.stringValue] = encodedValue
+        }
+    }
+
+    func encodeNil(forKey key: Key) throws {
+        insert(NSNull(), for: key)
+    }
+
+    func encode<T>(_ value: T, forKey key: Key) throws where T: Encodable {
+        let encoder = _JSValueEncoder(optionalEncodingStrategy: optionalEncodingStrategy)
+        try value.encode(to: encoder)
+        insert(.nestedContainer(encoder), for: key)
+    }
+
+    // This is a perectly valid name for this method. The underscore is to avoid a conflict with the
+    // protocol requirement.
+    //swiftlint:disable:next identifier_name
+    func _encodeIfPresent<T>(_ value: T?, forKey key: Key) throws where T: Encodable {
+        switch optionalEncodingStrategy {
+        case .explicitNulls:
+            if let value = value {
+                try encode(value, forKey: key)
+            } else {
+                try encodeNil(forKey: key)
+            }
+        case .undefined:
+            guard let value = value else { return }
+            try encode(value, forKey: key)
+        }
+    }
+
+    func encodeIfPresent<T>(_ value: T?, forKey key: Key) throws where T: Encodable {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: Bool?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: String?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: Double?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: Float?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: Int?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: Int8?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: Int16?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: Int32?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: Int64?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: UInt?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: UInt8?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: UInt16?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: UInt32?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func encodeIfPresent(_ value: UInt64?, forKey key: Key) throws {
+        try _encodeIfPresent(value, forKey: key)
+    }
+
+    func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type, forKey key: Key) -> KeyedEncodingContainer<NestedKey> where NestedKey: CodingKey {
+        var newPath = codingPath
+        newPath.append(key)
+
+        let nestedContainer = KeyedContainer<NestedKey>(
+            codingPath: newPath,
+            userInfo: userInfo,
+            optionalEncodingStrategy: optionalEncodingStrategy
+        )
+
+        insert(.nestedContainer(nestedContainer), for: key)
+        return KeyedEncodingContainer(nestedContainer)
+    }
+
+    func nestedUnkeyedContainer(forKey key: Key) -> UnkeyedEncodingContainer {
+        var newPath = codingPath
+        newPath.append(key)
+        let nestedContainer = UnkeyedContainer(
+            codingPath: codingPath,
+            userInfo: userInfo,
+            optionalEncodingStrategy: optionalEncodingStrategy
+        )
+        insert(.nestedContainer(nestedContainer), for: key)
+        return nestedContainer
+    }
+
+    enum SuperKey: String, CodingKey {
+        case `super`
+    }
+
+    func superEncoder() -> Encoder {
+        let encoder = _JSValueEncoder(optionalEncodingStrategy: optionalEncodingStrategy)
+        insert(.nestedContainer(encoder), for: SuperKey.super)
+        return encoder
+    }
+
+    func superEncoder(forKey key: Key) -> Encoder {
+        let encoder = _JSValueEncoder(optionalEncodingStrategy: optionalEncodingStrategy)
+        insert(.nestedContainer(encoder), for: key)
+        return encoder
+    }
+}
+
+private class AnyKeyedContainer: JSValueEncodingContainer {
+    var data: JSValue? { object() }
+    var object: () -> JSObject?
+
+    init<Key>(_ keyedContainer: KeyedContainer<Key>) where Key: CodingKey {
+        object = { keyedContainer.object }
+    }
+}
+
+extension KeyedContainer: JSValueEncodingContainer {
+    var data: JSValue? { object }
+}
+
+private final class UnkeyedContainer {
+    var array: JSArray? {
+        encodedUnkeyedValue?.reduce(into: []) { arr, next in
+            switch next {
+            case .value(let value):
+                arr.append(value)
+            case .nestedContainer(let container):
+                guard let data = container.data else { return }
+                arr.append(data)
+            }
+        }
+    }
+
+    var codingPath: [CodingKey]
+    var userInfo: CodingUserInfo
+    var optionalEncodingStrategy: JSValueEncoder.OptionalEncodingStrategy
+    private var encodedUnkeyedValue: [EncodedValue]?
+
+    init(codingPath: [CodingKey], userInfo: CodingUserInfo, optionalEncodingStrategy: JSValueEncoder.OptionalEncodingStrategy) {
+        self.codingPath = codingPath
+        self.userInfo = userInfo
+        self.optionalEncodingStrategy = optionalEncodingStrategy
+    }
+}
+
+extension UnkeyedContainer: UnkeyedEncodingContainer {
+    private func append(_ value: any JSValue) {
+        append(.value(value))
+    }
+
+    private func append(_ value: EncodedValue) {
+        if encodedUnkeyedValue == nil {
+            encodedUnkeyedValue = [value]
+        } else {
+            encodedUnkeyedValue!.append(value)
+        }
+    }
+
+    var count: Int {
+        array?.count ?? 0
+    }
+
+    func encodeNil() throws {
+        append(NSNull())
+    }
+
+    func encode<T>(_ value: T) throws where T: Encodable {
+        let encoder = _JSValueEncoder(optionalEncodingStrategy: optionalEncodingStrategy)
+        try value.encode(to: encoder)
+        append(.nestedContainer(encoder))
+    }
+
+    func nestedUnkeyedContainer() -> UnkeyedEncodingContainer {
+        let nestedContainer = UnkeyedContainer(
+            codingPath: codingPath,
+            userInfo: userInfo,
+            optionalEncodingStrategy: optionalEncodingStrategy
+        )
+        append(.nestedContainer(nestedContainer))
+        return nestedContainer
+    }
+
+    func nestedContainer<NestedKey>(keyedBy keyType: NestedKey.Type) -> KeyedEncodingContainer<NestedKey> where NestedKey: CodingKey {
+        let nestedContainer = KeyedContainer<NestedKey>(
+            codingPath: codingPath,
+            userInfo: userInfo,
+            optionalEncodingStrategy: optionalEncodingStrategy
+        )
+        append(.nestedContainer(nestedContainer))
+        return KeyedEncodingContainer(nestedContainer)
+    }
+
+    func superEncoder() -> Encoder {
+        let encoder = _JSValueEncoder(optionalEncodingStrategy: optionalEncodingStrategy)
+        append(.nestedContainer(encoder))
+        return encoder
+    }
+}
+
+extension UnkeyedContainer: JSValueEncodingContainer {
+    var data: JSValue? { array }
+}
+
+private final class SingleValueContainer {
+    var data: JSValue?
+    var codingPath: [CodingKey]
+    var userInfo: CodingUserInfo
+    var optionalEncodingStrategy: JSValueEncoder.OptionalEncodingStrategy
+
+    init(
+        codingPath: [CodingKey],
+        userInfo: CodingUserInfo,
+        optionalEncodingStrategy: JSValueEncoder.OptionalEncodingStrategy
+    ) {
+        self.codingPath = codingPath
+        self.userInfo = userInfo
+        self.optionalEncodingStrategy = optionalEncodingStrategy
+    }
+}
+
+extension SingleValueContainer: SingleValueEncodingContainer {
+    func encodeNil() throws {
+        data = NSNull()
+    }
+
+    func encode(_ value: Bool) throws {
+        data = value
+    }
+
+    func encode(_ value: String) throws {
+        data = value
+    }
+
+    func encode(_ value: Double) throws {
+        data = value as NSNumber
+    }
+
+    func encode(_ value: Float) throws {
+        data = value as NSNumber
+    }
+
+    func encode(_ value: Int) throws {
+        data = value as NSNumber
+    }
+
+    func encode(_ value: Int8) throws {
+        data = value as NSNumber
+    }
+
+    func encode(_ value: Int16) throws {
+        data = value as NSNumber
+    }
+
+    func encode(_ value: Int32) throws {
+        data = value as NSNumber
+    }
+
+    func encode(_ value: Int64) throws {
+        data = value as NSNumber
+    }
+
+    func encode(_ value: UInt) throws {
+        data = value as NSNumber
+    }
+
+    func encode(_ value: UInt8) throws {
+        data = value as NSNumber
+    }
+
+    func encode(_ value: UInt16) throws {
+        data = value as NSNumber
+    }
+
+    func encode(_ value: UInt32) throws {
+        data = value as NSNumber
+    }
+
+    func encode(_ value: UInt64) throws {
+        data = value as NSNumber
+    }
+
+    func encode<T>(_ value: T) throws where T: Encodable {
+        let encoder = _JSValueEncoder(optionalEncodingStrategy: optionalEncodingStrategy)
+        try value.encode(to: encoder)
+        data = encoder.data
+    }
+}
+
+extension SingleValueContainer: JSValueEncodingContainer {}

package/Capacitor/Capacitor/JSTypes.swift

@@ -173,6 +173,17 @@ extension JSValueContainer {
     public func getObject(_ key: String) -> JSObject? {
         return jsObjectRepresentation[key] as? JSObject
     }
+
+    /// Decodes a value of the given type for the given key.
+    /// - Parameters:
+    ///   - type: The type of the value to decode.
+    ///   - key: The key that the decoded value is associated with.
+    ///   - decoder: The decoder to use to decode the value. Defaults to `JSValueDecoder()`.
+    /// - Returns: A value of the requested type, if present for the given key and convertible to the requested type.
+    /// - Throws: `DecodingError` if the encountered encoded value is corrupted.
+    public func decode<T: Decodable>(_ type: T.Type, for key: String, with decoder: JSValueDecoder = JSValueDecoder()) throws -> T {
+        try decoder.decode(type, from: jsObjectRepresentation[key] ?? [:])
+    }
 }
 
 @objc protocol BridgedJSValueContainer: NSObjectProtocol {

package/Capacitor/Capacitor/assets/native-bridge.js

@@ -64,8 +64,52 @@ var nativeBridge = (function (exports) {
         }
         return newFormData;
     };
-    const convertBody = async (body) => {
-        if (body instanceof FormData) {
+    const convertBody = async (body, contentType) => {
+        if (body instanceof ReadableStream) {
+            const reader = body.getReader();
+            const chunks = [];
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                chunks.push(value);
+            }
+            const concatenated = new Uint8Array(chunks.reduce((acc, chunk) => acc + chunk.length, 0));
+            let position = 0;
+            for (const chunk of chunks) {
+                concatenated.set(chunk, position);
+                position += chunk.length;
+            }
+            let data = new TextDecoder().decode(concatenated);
+            let type;
+            if (contentType === 'application/json') {
+                try {
+                    data = JSON.parse(data);
+                }
+                catch (ignored) {
+                    // ignore
+                }
+                type = 'json';
+            }
+            else if (contentType === 'multipart/form-data') {
+                type = 'formData';
+            }
+            else if (contentType === null || contentType === void 0 ? void 0 : contentType.startsWith('image')) {
+                type = 'image';
+            }
+            else if (contentType === 'application/octet-stream') {
+                type = 'binary';
+            }
+            else {
+                type = 'text';
+            }
+            return {
+                data,
+                type,
+                headers: { 'Content-Type': contentType || 'application/octet-stream' },
+            };
+        }
+        else if (body instanceof FormData) {
             const formData = await convertFormData(body);
             const boundary = `${Date.now()}`;
             return {
@@ -432,8 +476,8 @@ var nativeBridge = (function (exports) {
                         console.time(tag);
                         try {
                             const { body, method } = request;
-                            const { data: requestData, type, headers, } = await convertBody(body || undefined);
                             const optionHeaders = Object.fromEntries(request.headers.entries());
+                            const { data: requestData, type, headers, } = await convertBody((options === null || options === void 0 ? void 0 : options.body) || body || undefined, optionHeaders['Content-Type'] || optionHeaders['content-type']);
                             const nativeResponse = await cap.nativePromise('CapacitorHttp', 'request', {
                                 url: request.url,
                                 method: method,

package/Capacitor.podspec

@@ -16,8 +16,8 @@ Pod::Spec.new do |s|
   s.ios.deployment_target = '13.0'
   s.authors = { 'Ionic Team' => 'hi@ionicframework.com' }
   s.source = { git: 'https://github.com/ionic-team/capacitor.git', tag: package['version'] }
-  s.source_files = "#{prefix}Capacitor/Capacitor/*.{swift,h,m}", "#{prefix}Capacitor/Capacitor/Plugins/*.{swift,h,m}",
-                   "#{prefix}Capacitor/Capacitor/Plugins/**/*.{swift,h,m}"
+  s.source_files = "#{prefix}Capacitor/Capacitor/*.{swift,h,m}", "#{prefix}Capacitor/Capacitor/Codable/*.{swift,h,m}",
+                   "#{prefix}Capacitor/Capacitor/Plugins/*.{swift,h,m}", "#{prefix}Capacitor/Capacitor/Plugins/**/*.{swift,h,m}"
   s.module_map = "#{prefix}Capacitor/Capacitor/Capacitor.modulemap"
   s.resources = ["#{prefix}Capacitor/Capacitor/assets/native-bridge.js"]
   s.dependency 'CapacitorCordova'

package/CapacitorCordova/CapacitorCordova/CapacitorCordova.h

@@ -20,4 +20,5 @@ FOUNDATION_EXPORT const unsigned char CapacitorCordovaVersionString[];
 #import <Cordova/CDVScreenOrientationDelegate.h>
 #import <Cordova/CDVURLProtocol.h>
 #import <Cordova/CDVViewController.h>
+#import <Cordova/CDVWebViewProcessPoolFactory.h>
 #import <Cordova/NSDictionary+CordovaPreferences.h>

package/CapacitorCordova/CapacitorCordova/Classes/Public/CDV.h

@@ -25,4 +25,4 @@
 #import "CDVViewController.h"
 #import "CDVURLProtocol.h"
 #import "CDVScreenOrientationDelegate.h"
-
+#import "CDVWebViewProcessPoolFactory.h"

package/CapacitorCordova/CapacitorCordova/Classes/Public/CDVWebViewProcessPoolFactory.h

@@ -0,0 +1,27 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ */
+
+#import <WebKit/WebKit.h>
+
+@interface CDVWebViewProcessPoolFactory : NSObject
+@property (nonatomic, retain) WKProcessPool* sharedPool;
+
++(instancetype) sharedFactory;
+-(WKProcessPool*) sharedProcessPool;
+@end

package/CapacitorCordova/CapacitorCordova/Classes/Public/CDVWebViewProcessPoolFactory.m

@@ -0,0 +1,49 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ */
+
+@import Foundation;
+@import WebKit;
+#import <Cordova/CDVWebViewProcessPoolFactory.h>
+
+static CDVWebViewProcessPoolFactory *factory = nil;
+
+@implementation CDVWebViewProcessPoolFactory
+
++ (instancetype)sharedFactory
+{
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        factory = [[CDVWebViewProcessPoolFactory alloc] init];
+    });
+    
+    return factory;
+}
+
+- (instancetype)init
+{
+    if (self = [super init]) {
+        _sharedPool = [[WKProcessPool alloc] init];
+    }
+    return self;
+}
+
+- (WKProcessPool*) sharedProcessPool {
+    return _sharedPool;
+}
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor/ios",
-  "version": "6.0.0-alpha.2",
+  "version": "6.0.0-beta.1",
   "description": "Capacitor: Cross-platform apps with JavaScript and the web",
   "homepage": "https://capacitorjs.com",
   "author": "Ionic Team <hi@ionic.io> (https://ionic.io)",
@@ -26,7 +26,7 @@
     "xc:build:xcframework": "scripts/build.sh xcframework"
   },
   "peerDependencies": {
-    "@capacitor/core": "^6.0.0-alpha.2"
+    "@capacitor/core": "^6.0.0-beta.1"
   },
   "publishConfig": {
     "access": "public"