@capacitor/ios 4.1.0 → 4.1.1-dev-7e3589f9.0

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,41 @@
+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 u = call.getString("url") else { return call.reject("Must provide a URL"); }
+        guard let _ = httpMethod ?? call.getString("method") else { return call.reject("Must provide an HTTP Method"); }
+        guard var _ = URL(string: u) else { return call.reject("Invalid URL"); }
+
+        do {
+            try HttpRequestHandler.request(call, httpMethod)
+        } catch let e {
+            call.reject(e.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,10 +2,26 @@
 
 #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(CAPConsolePlugin, "Console",
   CAP_PLUGIN_METHOD(log, CAPPluginReturnNone);
 )
 
+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(CAPWebViewPlugin, "WebView",
   CAP_PLUGIN_METHOD(setServerBasePath, CAPPluginReturnPromise);
   CAP_PLUGIN_METHOD(getServerBasePath, CAPPluginReturnPromise);

package/Capacitor/Capacitor/Plugins/HttpRequestHandler.swift

@@ -0,0 +1,172 @@
+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 u = URL(string: urlString) else {
+                throw URLError(.badURL)
+            }
+            url = u
+            return self
+        }
+
+        public func setMethod(_ method: String) -> CapacitorHttpRequestBuilder {
+            self.method = method
+            return self
+        }
+
+        public func setUrlParams(_ params: [String: Any]) -> CapacitorHttpRequestBuilder {
+            if params.count != 0 {
+                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) }
+        guard let method = httpMethod ?? call.getString("method") else { throw URLError(.dataNotAllowed) }
+
+        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,24 @@ 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 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
+                    }
+                }
+            }
+        } catch {
+            // Continue with regular prompt
+        }
+
         guard let viewController = bridge?.viewController else {
             return
         }

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

@@ -241,6 +241,209 @@ const 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');
+                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,
+                };
+                // fetch patch
+                window.fetch = async (resource, options) => {
+                    if (resource.toString().startsWith('data:')) {
+                        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,
+                        });
+                        // intercept & parse response before returning
+                        const response = new Response(JSON.stringify(nativeResponse.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 () {
+                    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,
+                        },
+                    });
+                    this.readyState = 0;
+                    this.dispatchEvent(new Event('abort'));
+                    this.dispatchEvent(new Event('loadend'));
+                };
+                // XHR patch open
+                window.XMLHttpRequest.prototype.open = function (method, url) {
+                    this.abort();
+                    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.status = nativeResponse.status;
+                                this.response = nativeResponse.data;
+                                this.responseText = 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.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.response = error;
+                        this.responseText = error.toString();
+                        this.responseURL = this._url;
+                        this.readyState = 4;
+                        this.dispatchEvent(new Event('error'));
+                        this.dispatchEvent(new Event('loadend'));
+                    }
+                };
+            }
             // patch window.console on iOS and store original console fns
             const isIos = getPlatformId(win) === 'ios';
             if (win.console && isIos) {

package/LICENSE

@@ -1,23 +1,21 @@
-Copyright 2017-present Ionic
-https://ionic.io
-
 MIT License
 
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
+Copyright (c) 2017-present Drifty Co.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor/ios",
-  "version": "4.1.0",
+  "version": "4.1.1-dev-7e3589f9.0",
   "description": "Capacitor: Cross-platform apps with JavaScript and the web",
   "homepage": "https://capacitorjs.com",
   "author": "Ionic Team <hi@ionic.io> (https://ionic.io)",
@@ -25,10 +25,10 @@
     "xc:build:CapacitorCordova": "cd CapacitorCordova && xcodebuild && cd .."
   },
   "peerDependencies": {
-    "@capacitor/core": "^4.0.0"
+    "@capacitor/core": "^4.1.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "0b5c2b740e9613512a100051b8822fd1361f4aeb"
+  "gitHead": "7e3589f9bb4673b595f2718e444e2bd07c7749e1"
 }