@capacitor/ios 4.2.1-nightly-20220921T150520.0 → 4.3.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [4.3.0](https://github.com/ionic-team/capacitor/compare/4.2.0...4.3.0) (2022-09-21)
+
+
+### Bug Fixes
+
+* **core:** Exception object was not set on Cap ([#5917](https://github.com/ionic-team/capacitor/issues/5917)) ([9ca27a4](https://github.com/ionic-team/capacitor/commit/9ca27a4f8441b368f8bf9d97dda57b1a55ac0e4e))
+
+
+### Features
+
+* Capacitor Cookies & Capacitor Http core plugins ([d4047cf](https://github.com/ionic-team/capacitor/commit/d4047cfa947676777f400389a8d65defae140b45))
+
+
+
+
+
 # [4.2.0](https://github.com/ionic-team/capacitor/compare/4.1.0...4.2.0) (2022-09-08)
 
 **Note:** Version bump only for package @capacitor/ios

package/Capacitor/Capacitor/Plugins/CapacitorCookieManager.swift

@@ -0,0 +1,66 @@
+import Foundation
+
+public class CapacitorCookieManager {
+    var config: InstanceConfiguration?
+
+    init(_ capConfig: InstanceConfiguration?) {
+        self.config = capConfig
+    }
+
+    public func getServerUrl() -> URL? {
+        return self.config?.serverURL
+    }
+
+    public func getServerUrl(_ call: CAPPluginCall) -> URL? {
+        guard let urlString = call.getString("url") else {
+            return getServerUrl()
+        }
+
+        guard let url = URL(string: urlString) else {
+            return getServerUrl()
+        }
+
+        return url
+    }
+
+    public func encode(_ value: String) -> String {
+        return value.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed)!
+    }
+
+    public func decode(_ value: String) -> String {
+        return value.removingPercentEncoding!
+    }
+
+    public func setCookie(_ url: URL, _ key: String, _ value: String) {
+        let jar = HTTPCookieStorage.shared
+        let field = ["Set-Cookie": "\(key)=\(value)"]
+        let cookies = HTTPCookie.cookies(withResponseHeaderFields: field, for: url)
+        jar.setCookies(cookies, for: url, mainDocumentURL: url)
+    }
+
+    public func getCookies() -> String {
+        let jar = HTTPCookieStorage.shared
+        guard let url = self.getServerUrl() else { return "" }
+        guard let cookies = jar.cookies(for: url) else { return "" }
+        return cookies.map({"\($0.name)=\($0.value)"}).joined(separator: ";")
+    }
+
+    public func deleteCookie(_ url: URL, _ key: String) {
+        let jar = HTTPCookieStorage.shared
+        let cookie = jar.cookies(for: url)?.first(where: { (cookie) -> Bool in
+            return cookie.name == key
+        })
+
+        if cookie != nil { jar.deleteCookie(cookie!) }
+    }
+
+    public func clearCookies(_ url: URL) {
+        let jar = HTTPCookieStorage.shared
+        jar.cookies(for: url)?.forEach({ (cookie) in jar.deleteCookie(cookie) })
+    }
+
+    public func clearAllCookies() {
+        let jar = HTTPCookieStorage.shared
+        jar.cookies?.forEach({ (cookie) in jar.deleteCookie(cookie) })
+    }
+}

package/Capacitor/Capacitor/Plugins/CapacitorCookies.swift

@@ -0,0 +1,52 @@
+import Foundation
+
+@objc(CAPCookiesPlugin)
+public class CAPCookiesPlugin: CAPPlugin {
+    var cookieManager: CapacitorCookieManager?
+
+    @objc override public func load() {
+        cookieManager = CapacitorCookieManager(bridge?.config)
+    }
+
+    @objc func setCookie(_ call: CAPPluginCall) {
+        guard let key = call.getString("key") else { return call.reject("Must provide key") }
+        guard let value = call.getString("value") else { return call.reject("Must provide value") }
+
+        let url = cookieManager!.getServerUrl(call)
+        if url != nil {
+            cookieManager!.setCookie(url!, key, cookieManager!.encode(value))
+            call.resolve()
+        }
+    }
+
+    @objc func deleteCookie(_ call: CAPPluginCall) {
+        guard let key = call.getString("key") else { return call.reject("Must provide key") }
+        let url = cookieManager!.getServerUrl(call)
+        if url != nil {
+            let jar = HTTPCookieStorage.shared
+
+            let cookie = jar.cookies(for: url!)?.first(where: { (cookie) -> Bool in
+                return cookie.name == key
+            })
+
+            if cookie != nil {
+                jar.deleteCookie(cookie!)
+            }
+
+            call.resolve()
+        }
+    }
+
+    @objc func clearCookies(_ call: CAPPluginCall) {
+        let url = cookieManager!.getServerUrl(call)
+        if url != nil {
+            cookieManager!.clearCookies(url!)
+            call.resolve()
+        }
+    }
+
+    @objc func clearAllCookies(_ call: CAPPluginCall) {
+        cookieManager!.clearAllCookies()
+        call.resolve()
+    }
+}

package/Capacitor/Capacitor/Plugins/CapacitorHttp.swift

@@ -0,0 +1,40 @@
+import Foundation
+
+@objc(CAPHttpPlugin)
+public class CAPHttpPlugin: CAPPlugin {
+    @objc func http(_ call: CAPPluginCall, _ httpMethod: String?) {
+        // Protect against bad values from JS before calling request
+        guard let url = call.getString("url") else { return call.reject("Must provide a URL"); }
+        guard var _ = URL(string: url) else { return call.reject("Invalid URL"); }
+
+        do {
+            try HttpRequestHandler.request(call, httpMethod)
+        } catch let error {
+            call.reject(error.localizedDescription)
+        }
+    }
+
+    @objc func request(_ call: CAPPluginCall) {
+        http(call, nil)
+    }
+
+    @objc func get(_ call: CAPPluginCall) {
+        http(call, "GET")
+    }
+
+    @objc func post(_ call: CAPPluginCall) {
+        http(call, "POST")
+    }
+
+    @objc func put(_ call: CAPPluginCall) {
+        http(call, "PUT")
+    }
+
+    @objc func patch(_ call: CAPPluginCall) {
+        http(call, "PATCH")
+    }
+
+    @objc func del(_ call: CAPPluginCall) {
+        http(call, "DELETE")
+    }
+}

package/Capacitor/Capacitor/Plugins/CapacitorUrlRequest.swift

@@ -0,0 +1,150 @@
+import Foundation
+
+public class CapacitorUrlRequest: NSObject, URLSessionTaskDelegate {
+    private var request: URLRequest
+    private var headers: [String: String]
+
+    enum CapacitorUrlRequestError: Error {
+        case serializationError(String?)
+    }
+
+    init(_ url: URL, method: String) {
+        request = URLRequest(url: url)
+        request.httpMethod = method
+        headers = [:]
+        if let lang = Locale.autoupdatingCurrent.languageCode {
+            if let country = Locale.autoupdatingCurrent.regionCode {
+                headers["Accept-Language"] = "\(lang)-\(country),\(lang);q=0.5"
+            } else {
+                headers["Accept-Language"] = "\(lang);q=0.5"
+            }
+            request.addValue(headers["Accept-Language"]!, forHTTPHeaderField: "Accept-Language")
+        }
+    }
+
+    private func getRequestDataAsJson(_ data: JSValue) throws -> Data? {
+        // We need to check if the JSON is valid before attempting to serialize, as JSONSerialization.data will not throw an exception that can be caught, and will cause the application to crash if it fails.
+        if JSONSerialization.isValidJSONObject(data) {
+            return try JSONSerialization.data(withJSONObject: data)
+        } else {
+            throw CapacitorUrlRequest.CapacitorUrlRequestError.serializationError("[ data ] argument for request of content-type [ application/json ] must be serializable to JSON")
+        }
+    }
+
+    private func getRequestDataAsFormUrlEncoded(_ data: JSValue) throws -> Data? {
+        guard var components = URLComponents(url: request.url!, resolvingAgainstBaseURL: false) else { return nil }
+        components.queryItems = []
+
+        guard let obj = data as? JSObject else {
+            // Throw, other data types explicitly not supported
+            throw CapacitorUrlRequestError.serializationError("[ data ] argument for request with content-type [ multipart/form-data ] may only be a plain javascript object")
+        }
+
+        obj.keys.forEach { (key: String) in
+            components.queryItems?.append(URLQueryItem(name: key, value: "\(obj[key] ?? "")"))
+        }
+
+        if components.query != nil {
+            return Data(components.query!.utf8)
+        }
+
+        return nil
+    }
+
+    private func getRequestDataAsMultipartFormData(_ data: JSValue) throws -> Data {
+        guard let obj = data as? JSObject else {
+            // Throw, other data types explicitly not supported.
+            throw CapacitorUrlRequestError.serializationError("[ data ] argument for request with content-type [ application/x-www-form-urlencoded ] may only be a plain javascript object")
+        }
+
+        let strings: [String: String] = obj.compactMapValues { any in
+            any as? String
+        }
+
+        var data = Data()
+        let boundary = UUID().uuidString
+        let contentType = "multipart/form-data; boundary=\(boundary)"
+        request.setValue(contentType, forHTTPHeaderField: "Content-Type")
+        headers["Content-Type"] = contentType
+
+        strings.forEach { key, value in
+            data.append("\r\n--\(boundary)\r\n".data(using: .utf8)!)
+            data.append("Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n".data(using: .utf8)!)
+            data.append(value.data(using: .utf8)!)
+        }
+        data.append("\r\n--\(boundary)--\r\n".data(using: .utf8)!)
+
+        return data
+    }
+
+    private func getRequestDataAsString(_ data: JSValue) throws -> Data {
+        guard let stringData = data as? String else {
+            throw CapacitorUrlRequestError.serializationError("[ data ] argument could not be parsed as string")
+        }
+        return Data(stringData.utf8)
+    }
+
+    func getRequestHeader(_ index: String) -> Any? {
+        var normalized = [:] as [String: Any]
+        self.headers.keys.forEach { (key: String) in
+            normalized[key.lowercased()] = self.headers[key]
+        }
+
+        return normalized[index.lowercased()]
+    }
+
+    func getRequestData(_ body: JSValue, _ contentType: String) throws -> Data? {
+        // If data can be parsed directly as a string, return that without processing.
+        if let strVal = try? getRequestDataAsString(body) {
+            return strVal
+        } else if contentType.contains("application/json") {
+            return try getRequestDataAsJson(body)
+        } else if contentType.contains("application/x-www-form-urlencoded") {
+            return try getRequestDataAsFormUrlEncoded(body)
+        } else if contentType.contains("multipart/form-data") {
+            return try getRequestDataAsMultipartFormData(body)
+        } else {
+            throw CapacitorUrlRequestError.serializationError("[ data ] argument could not be parsed for content type [ \(contentType) ]")
+        }
+    }
+
+    public func setRequestHeaders(_ headers: [String: String]) {
+        headers.keys.forEach { (key: String) in
+            let value = headers[key]
+            request.addValue(value!, forHTTPHeaderField: key)
+            self.headers[key] = value
+        }
+    }
+
+    public func setRequestBody(_ body: JSValue) throws {
+        let contentType = self.getRequestHeader("Content-Type") as? String
+
+        if contentType != nil {
+            request.httpBody = try getRequestData(body, contentType!)
+        }
+    }
+
+    public func setContentType(_ data: String?) {
+        request.setValue(data, forHTTPHeaderField: "Content-Type")
+    }
+
+    public func setTimeout(_ timeout: TimeInterval) {
+        request.timeoutInterval = timeout
+    }
+
+    public func getUrlRequest() -> URLRequest {
+        return request
+    }
+
+    public func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse, newRequest request: URLRequest, completionHandler: @escaping (URLRequest?) -> Void) {
+        completionHandler(nil)
+    }
+
+    public func getUrlSession(_ call: CAPPluginCall) -> URLSession {
+        let disableRedirects = call.getBool("disableRedirects") ?? false
+        if !disableRedirects {
+            return URLSession.shared
+        }
+        return URLSession(configuration: URLSessionConfiguration.default, delegate: self, delegateQueue: nil)
+    }
+}

package/Capacitor/Capacitor/Plugins/DefaultPlugins.m

@@ -2,6 +2,22 @@
 
 #import "CAPBridgedPlugin.h"
 
+CAP_PLUGIN(CAPCookiesPlugin, "CapacitorCookies",
+  CAP_PLUGIN_METHOD(setCookie, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(deleteCookie, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(clearCookies, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(clearAllCookies, CAPPluginReturnPromise);
+)
+
+CAP_PLUGIN(CAPHttpPlugin, "CapacitorHttp",
+  CAP_PLUGIN_METHOD(request, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(get, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(post, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(put, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(patch, CAPPluginReturnPromise);
+  CAP_PLUGIN_METHOD(delete, CAPPluginReturnPromise);
+)
+
 CAP_PLUGIN(CAPConsolePlugin, "Console",
   CAP_PLUGIN_METHOD(log, CAPPluginReturnNone);
 )

package/Capacitor/Capacitor/Plugins/HttpRequestHandler.swift

@@ -0,0 +1,174 @@
+import Foundation
+
+/// See https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType
+private enum ResponseType: String {
+    case arrayBuffer = "arraybuffer"
+    case blob = "blob"
+    case document = "document"
+    case json = "json"
+    case text = "text"
+
+    static let `default`: ResponseType = .text
+
+    init(string: String?) {
+        guard let string = string else {
+            self = .default
+            return
+        }
+
+        guard let responseType = ResponseType(rawValue: string.lowercased()) else {
+            self = .default
+            return
+        }
+
+        self = responseType
+    }
+}
+
+/// Helper that safely parses JSON Data. Otherwise returns an error (without throwing)
+/// - Parameters:
+///     - data: The JSON Data to parse
+/// - Returns: The parsed value or an error
+func tryParseJson(_ data: Data) -> Any {
+    do {
+        return try JSONSerialization.jsonObject(with: data, options: .mutableContainers)
+    } catch {
+        return error.localizedDescription
+    }
+}
+
+class HttpRequestHandler {
+    private class CapacitorHttpRequestBuilder {
+        private var url: URL?
+        private var method: String?
+        private var params: [String: String]?
+        private var request: CapacitorUrlRequest?
+
+        /// Set the URL of the HttpRequest
+        /// - Throws: an error of URLError if the urlString cannot be parsed
+        /// - Parameters:
+        ///     - urlString: The URL value to parse
+        /// - Returns: self to continue chaining functions
+        public func setUrl(_ urlString: String) throws -> CapacitorHttpRequestBuilder {
+            guard let url = URL(string: urlString) else {
+                throw URLError(.badURL)
+            }
+            self.url = url
+            return self
+        }
+
+        public func setMethod(_ method: String) -> CapacitorHttpRequestBuilder {
+            self.method = method
+            return self
+        }
+
+        public func setUrlParams(_ params: [String: Any]) -> CapacitorHttpRequestBuilder {
+            if params.count != 0 {
+                // swiftlint:disable force_cast
+                var cmps = URLComponents(url: url!, resolvingAgainstBaseURL: true)
+                if cmps?.queryItems == nil {
+                    cmps?.queryItems = []
+                }
+
+                var urlSafeParams: [URLQueryItem] = []
+                for (key, value) in params {
+                    if let arr = value as? [String] {
+                        arr.forEach { str in
+                            urlSafeParams.append(URLQueryItem(name: key, value: str))
+                        }
+                    } else {
+                        urlSafeParams.append(URLQueryItem(name: key, value: (value as! String)))
+                    }
+                }
+
+                cmps!.queryItems?.append(contentsOf: urlSafeParams)
+                url = cmps!.url!
+            }
+            return self
+        }
+
+        public func openConnection() -> CapacitorHttpRequestBuilder {
+            request = CapacitorUrlRequest(url!, method: method!)
+            return self
+        }
+
+        public func build() -> CapacitorUrlRequest {
+            return request!
+        }
+    }
+
+    private static func buildResponse(_ data: Data?, _ response: HTTPURLResponse, responseType: ResponseType = .default) -> [String: Any] {
+        var output = [:] as [String: Any]
+
+        output["status"] = response.statusCode
+        output["headers"] = response.allHeaderFields
+        output["url"] = response.url?.absoluteString
+
+        guard let data = data else {
+            output["data"] = ""
+            return output
+        }
+
+        let contentType = (response.allHeaderFields["Content-Type"] as? String ?? "application/default").lowercased()
+
+        if contentType.contains("application/json") || responseType == .json {
+            output["data"] = tryParseJson(data)
+        } else if responseType == .arrayBuffer || responseType == .blob {
+            output["data"] = data.base64EncodedString()
+        } else if responseType == .document || responseType == .text || responseType == .default {
+            output["data"] = String(data: data, encoding: .utf8)
+        }
+
+        return output
+    }
+
+    public static func request(_ call: CAPPluginCall, _ httpMethod: String?) throws {
+        guard let urlString = call.getString("url") else { throw URLError(.badURL) }
+        let method = httpMethod ?? call.getString("method", "GET")
+
+        // swiftlint:disable force_cast
+        let headers = (call.getObject("headers") ?? [:]) as! [String: String]
+        let params = (call.getObject("params") ?? [:]) as [String: Any]
+        let responseType = call.getString("responseType") ?? "text"
+        let connectTimeout = call.getDouble("connectTimeout")
+        let readTimeout = call.getDouble("readTimeout")
+
+        let request = try CapacitorHttpRequestBuilder()
+            .setUrl(urlString)
+            .setMethod(method)
+            .setUrlParams(params)
+            .openConnection()
+            .build()
+
+        request.setRequestHeaders(headers)
+
+        // Timeouts in iOS are in seconds. So read the value in millis and divide by 1000
+        let timeout = (connectTimeout ?? readTimeout ?? 600000.0) / 1000.0
+        request.setTimeout(timeout)
+
+        if let data = call.options["data"] as? JSValue {
+            do {
+                try request.setRequestBody(data)
+            } catch {
+                // Explicitly reject if the http request body was not set successfully,
+                // so as to not send a known malformed request, and to provide the developer with additional context.
+                call.reject("Error", "REQUEST", error, [:])
+                return
+            }
+        }
+
+        let urlRequest = request.getUrlRequest()
+        let urlSession = request.getUrlSession(call)
+        let task = urlSession.dataTask(with: urlRequest) { (data, response, error) in
+            urlSession.invalidateAndCancel()
+            if error != nil {
+                return
+            }
+
+            let type = ResponseType(rawValue: responseType) ?? .default
+            call.resolve(self.buildResponse(data, response as! HTTPURLResponse, responseType: type))
+        }
+
+        task.resume()
+    }
+}

package/Capacitor/Capacitor/WebViewDelegationHandler.swift

@@ -243,6 +243,34 @@ internal class WebViewDelegationHandler: NSObject, WKNavigationDelegate, WKUIDel
     }
 
     public func webView(_ webView: WKWebView, runJavaScriptTextInputPanelWithPrompt prompt: String, defaultText: String?, initiatedByFrame frame: WKFrameInfo, completionHandler: @escaping (String?) -> Void) {
+
+        // Check if this is synchronous cookie or http call
+        do {
+            if let dataFromString = prompt.data(using: .utf8, allowLossyConversion: false) {
+                if let payload = try JSONSerialization.jsonObject(with: dataFromString, options: .fragmentsAllowed) as? [String: AnyObject] {
+                    let type = payload["type"] as? String
+
+                    if type == "CapacitorCookies" {
+                        completionHandler(CapacitorCookieManager(bridge!.config).getCookies())
+                        // Don't present prompt
+                        return
+                    } else if type == "CapacitorCookies.isEnabled" {
+                        let pluginConfig = bridge!.config.getPluginConfig("CapacitorCookies")
+                        completionHandler(String(pluginConfig.getBoolean("enabled", false)))
+                        // Don't present prompt
+                        return
+                    } else if type == "CapacitorHttp" {
+                        let pluginConfig = bridge!.config.getPluginConfig("CapacitorHttp")
+                        completionHandler(String(pluginConfig.getBoolean("enabled", false)))
+                        // Don't present prompt
+                        return
+                    }
+                }
+            }
+        } catch {
+            // Continue with regular prompt
+        }
+
         guard let viewController = bridge?.viewController else {
             return
         }

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

@@ -2,7 +2,7 @@
 /*! Capacitor: https://capacitorjs.com/ - MIT License */
 /* Generated File. Do not edit. */
 
-var nativeBridge = (function (exports) {
+const nativeBridge = (function (exports) {
     'use strict';
 
     var ExceptionCode;
@@ -268,6 +268,274 @@ var nativeBridge = (function (exports) {
                 }
                 return String(msg);
             };
+            /**
+             * Safely web decode a string value (inspired by js-cookie)
+             * @param str The string value to decode
+             */
+            const decode = (str) => str.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+            const platform = getPlatformId(win);
+            if (platform == 'android' || platform == 'ios') {
+                // patch document.cookie on Android/iOS
+                win.CapacitorCookiesDescriptor =
+                    Object.getOwnPropertyDescriptor(Document.prototype, 'cookie') ||
+                        Object.getOwnPropertyDescriptor(HTMLDocument.prototype, 'cookie');
+                let doPatchCookies = false;
+                // check if capacitor cookies is disabled before patching
+                if (platform === 'ios') {
+                    // Use prompt to synchronously get capacitor cookies config.
+                    // https://stackoverflow.com/questions/29249132/wkwebview-complex-communication-between-javascript-native-code/49474323#49474323
+                    const payload = {
+                        type: 'CapacitorCookies.isEnabled',
+                    };
+                    const isCookiesEnabled = prompt(JSON.stringify(payload));
+                    if (isCookiesEnabled === 'true') {
+                        doPatchCookies = true;
+                    }
+                }
+                else if (typeof win.CapacitorCookiesAndroidInterface !== 'undefined') {
+                    const isCookiesEnabled = win.CapacitorCookiesAndroidInterface.isEnabled();
+                    if (isCookiesEnabled === true) {
+                        doPatchCookies = true;
+                    }
+                }
+                if (doPatchCookies) {
+                    Object.defineProperty(document, 'cookie', {
+                        get: function () {
+                            if (platform === 'ios') {
+                                // Use prompt to synchronously get cookies.
+                                // https://stackoverflow.com/questions/29249132/wkwebview-complex-communication-between-javascript-native-code/49474323#49474323
+                                const payload = {
+                                    type: 'CapacitorCookies',
+                                };
+                                const res = prompt(JSON.stringify(payload));
+                                return res;
+                            }
+                            else if (typeof win.CapacitorCookiesAndroidInterface !== 'undefined') {
+                                return win.CapacitorCookiesAndroidInterface.getCookies();
+                            }
+                        },
+                        set: function (val) {
+                            const cookiePairs = val.split(';');
+                            for (const cookiePair of cookiePairs) {
+                                const cookieKey = cookiePair.split('=')[0];
+                                const cookieValue = cookiePair.split('=')[1];
+                                if (null == cookieValue) {
+                                    continue;
+                                }
+                                cap.toNative('CapacitorCookies', 'setCookie', {
+                                    key: cookieKey,
+                                    value: decode(cookieValue),
+                                });
+                            }
+                        },
+                    });
+                }
+                // patch fetch / XHR on Android/iOS
+                // store original fetch & XHR functions
+                win.CapacitorWebFetch = window.fetch;
+                win.CapacitorWebXMLHttpRequest = {
+                    abort: window.XMLHttpRequest.prototype.abort,
+                    open: window.XMLHttpRequest.prototype.open,
+                    send: window.XMLHttpRequest.prototype.send,
+                    setRequestHeader: window.XMLHttpRequest.prototype.setRequestHeader,
+                };
+                let doPatchHttp = false;
+                // check if capacitor http is disabled before patching
+                if (platform === 'ios') {
+                    // Use prompt to synchronously get capacitor http config.
+                    // https://stackoverflow.com/questions/29249132/wkwebview-complex-communication-between-javascript-native-code/49474323#49474323
+                    const payload = {
+                        type: 'CapacitorHttp',
+                    };
+                    const isHttpEnabled = prompt(JSON.stringify(payload));
+                    if (isHttpEnabled === 'true') {
+                        doPatchHttp = true;
+                    }
+                }
+                else if (typeof win.CapacitorHttpAndroidInterface !== 'undefined') {
+                    const isHttpEnabled = win.CapacitorHttpAndroidInterface.isEnabled();
+                    if (isHttpEnabled === true) {
+                        doPatchHttp = true;
+                    }
+                }
+                if (doPatchHttp) {
+                    // fetch patch
+                    window.fetch = async (resource, options) => {
+                        if (resource.toString().startsWith('data:') ||
+                            resource.toString().startsWith('blob:')) {
+                            return win.CapacitorWebFetch(resource, options);
+                        }
+                        try {
+                            // intercept request & pass to the bridge
+                            const nativeResponse = await cap.nativePromise('CapacitorHttp', 'request', {
+                                url: resource,
+                                method: (options === null || options === void 0 ? void 0 : options.method) ? options.method : undefined,
+                                data: (options === null || options === void 0 ? void 0 : options.body) ? options.body : undefined,
+                                headers: (options === null || options === void 0 ? void 0 : options.headers) ? options.headers : undefined,
+                            });
+                            const data = typeof nativeResponse.data === 'string'
+                                ? nativeResponse.data
+                                : JSON.stringify(nativeResponse.data);
+                            // intercept & parse response before returning
+                            const response = new Response(data, {
+                                headers: nativeResponse.headers,
+                                status: nativeResponse.status,
+                            });
+                            return response;
+                        }
+                        catch (error) {
+                            return Promise.reject(error);
+                        }
+                    };
+                    // XHR event listeners
+                    const addEventListeners = function () {
+                        this.addEventListener('abort', function () {
+                            if (typeof this.onabort === 'function')
+                                this.onabort();
+                        });
+                        this.addEventListener('error', function () {
+                            if (typeof this.onerror === 'function')
+                                this.onerror();
+                        });
+                        this.addEventListener('load', function () {
+                            if (typeof this.onload === 'function')
+                                this.onload();
+                        });
+                        this.addEventListener('loadend', function () {
+                            if (typeof this.onloadend === 'function')
+                                this.onloadend();
+                        });
+                        this.addEventListener('loadstart', function () {
+                            if (typeof this.onloadstart === 'function')
+                                this.onloadstart();
+                        });
+                        this.addEventListener('readystatechange', function () {
+                            if (typeof this.onreadystatechange === 'function')
+                                this.onreadystatechange();
+                        });
+                        this.addEventListener('timeout', function () {
+                            if (typeof this.ontimeout === 'function')
+                                this.ontimeout();
+                        });
+                    };
+                    // XHR patch abort
+                    window.XMLHttpRequest.prototype.abort = function () {
+                        this.readyState = 0;
+                        this.dispatchEvent(new Event('abort'));
+                        this.dispatchEvent(new Event('loadend'));
+                    };
+                    // XHR patch open
+                    window.XMLHttpRequest.prototype.open = function (method, url) {
+                        Object.defineProperties(this, {
+                            _headers: {
+                                value: {},
+                                writable: true,
+                            },
+                            readyState: {
+                                get: function () {
+                                    var _a;
+                                    return (_a = this._readyState) !== null && _a !== void 0 ? _a : 0;
+                                },
+                                set: function (val) {
+                                    this._readyState = val;
+                                    this.dispatchEvent(new Event('readystatechange'));
+                                },
+                            },
+                            response: {
+                                value: '',
+                                writable: true,
+                            },
+                            responseText: {
+                                value: '',
+                                writable: true,
+                            },
+                            responseURL: {
+                                value: '',
+                                writable: true,
+                            },
+                            status: {
+                                value: 0,
+                                writable: true,
+                            },
+                        });
+                        addEventListeners.call(this);
+                        this._method = method;
+                        this._url = url;
+                        this.readyState = 1;
+                    };
+                    // XHR patch set request header
+                    window.XMLHttpRequest.prototype.setRequestHeader = function (header, value) {
+                        this._headers[header] = value;
+                    };
+                    // XHR patch send
+                    window.XMLHttpRequest.prototype.send = function (body) {
+                        try {
+                            this.readyState = 2;
+                            // intercept request & pass to the bridge
+                            cap
+                                .nativePromise('CapacitorHttp', 'request', {
+                                url: this._url,
+                                method: this._method,
+                                data: body !== null ? body : undefined,
+                                headers: this._headers,
+                            })
+                                .then((nativeResponse) => {
+                                // intercept & parse response before returning
+                                if (this.readyState == 2) {
+                                    this.dispatchEvent(new Event('loadstart'));
+                                    this._headers = nativeResponse.headers;
+                                    this.status = nativeResponse.status;
+                                    this.response = nativeResponse.data;
+                                    this.responseText =
+                                        typeof nativeResponse.data === 'string'
+                                            ? nativeResponse.data
+                                            : JSON.stringify(nativeResponse.data);
+                                    this.responseURL = nativeResponse.url;
+                                    this.readyState = 4;
+                                    this.dispatchEvent(new Event('load'));
+                                    this.dispatchEvent(new Event('loadend'));
+                                }
+                            })
+                                .catch((error) => {
+                                this.dispatchEvent(new Event('loadstart'));
+                                this.status = error.status;
+                                this._headers = error.headers;
+                                this.response = error.data;
+                                this.responseText = JSON.stringify(error.data);
+                                this.responseURL = error.url;
+                                this.readyState = 4;
+                                this.dispatchEvent(new Event('error'));
+                                this.dispatchEvent(new Event('loadend'));
+                            });
+                        }
+                        catch (error) {
+                            this.dispatchEvent(new Event('loadstart'));
+                            this.status = 500;
+                            this._headers = {};
+                            this.response = error;
+                            this.responseText = error.toString();
+                            this.responseURL = this._url;
+                            this.readyState = 4;
+                            this.dispatchEvent(new Event('error'));
+                            this.dispatchEvent(new Event('loadend'));
+                        }
+                    };
+                    // XHR patch getAllResponseHeaders
+                    window.XMLHttpRequest.prototype.getAllResponseHeaders = function () {
+                        let returnString = '';
+                        for (const key in this._headers) {
+                            if (key != 'Set-Cookie') {
+                                returnString += key + ': ' + this._headers[key] + '\r\n';
+                            }
+                        }
+                        return returnString;
+                    };
+                    // XHR patch getResponseHeader
+                    window.XMLHttpRequest.prototype.getResponseHeader = function (name) {
+                        return this._headers[name];
+                    };
+                }
+            }
             // patch window.console on iOS and store original console fns
             const isIos = getPlatformId(win) === 'ios';
             if (win.console && isIos) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor/ios",
-  "version": "4.2.1-nightly-20220921T150520.0",
+  "version": "4.3.0",
   "description": "Capacitor: Cross-platform apps with JavaScript and the web",
   "homepage": "https://capacitorjs.com",
   "author": "Ionic Team <hi@ionic.io> (https://ionic.io)",
@@ -30,5 +30,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4706f8325864d6c32bc0ad7ff9c07848bcf32ccd"
+  "gitHead": "3d4433b505252d263784ec0fafc72a9b7cd8591e"
 }