@capacitor-plus/ios 8.0.0-beta.0

package/Capacitor/Capacitor/Info.plist

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>NSPrincipalClass</key>
+	<string></string>
+</dict>
+</plist>

package/Capacitor/Capacitor/JS.swift

@@ -0,0 +1,122 @@
+import Foundation
+
+public class JSDate {
+    @available(*, deprecated, message: "No longer needed. Dates will be mapped to strings during serialization.")
+    static func toString(_ date: Date) -> String {
+        let formatter = ISO8601DateFormatter()
+        return formatter.string(from: date)
+    }
+}
+
+@available(*, deprecated, renamed: "PluginCallResultData")
+public typealias JSResultBody = [String: Any]
+
+/**
+ * A call originating from JavaScript land
+ */
+internal struct JSCall {
+    let options: [String: Any]
+    let pluginId: String
+    let method: String
+    let callbackId: String
+}
+
+internal protocol JSResultProtocol {
+    var call: JSCall { get }
+    var callbackID: String { get }
+    var pluginID: String { get }
+    var methodName: String { get }
+    func jsonPayload() -> String
+}
+
+internal extension JSResultProtocol {
+    var callbackID: String {
+        return call.callbackId
+    }
+
+    var pluginID: String {
+        return call.pluginId
+    }
+
+    var methodName: String {
+        return call.method
+    }
+}
+
+private enum SerializationResult: String {
+    case undefined = "undefined"
+    case empty = "{}"
+}
+
+/**
+ * A result of processing a JSCall, contains
+ * a reference to the original call and the new result.
+ */
+
+internal struct JSResult: JSResultProtocol {
+    let call: JSCall
+    let result: PluginCallResult?
+
+    func jsonPayload() -> String {
+        guard let result = result else {
+            return SerializationResult.undefined.rawValue
+        }
+        do {
+            if let payload = try result.jsonRepresentation() {
+                return payload
+            }
+        } catch PluginCallResult.SerializationError.invalidObject {
+            CAPLog.print("[Capacitor Plugin Error] - \(call.pluginId) - \(call.method) - Unable to serialize plugin response as JSON." +
+                            "Ensure that all data passed to success callback from module method is JSON serializable!")
+        } catch {
+            CAPLog.print("Unable to serialize plugin response as JSON: \(error.localizedDescription)")
+        }
+        return SerializationResult.empty.rawValue
+    }
+}
+
+internal extension JSResult {
+    init(call: JSCall, callResult: CAPPluginCallResult) {
+        self.call = call
+        self.result = callResult.resultData
+    }
+}
+
+internal struct JSResultError: JSResultProtocol {
+    let call: JSCall
+    let errorMessage: String
+    let errorDescription: String
+    let errorCode: String?
+    let result: PluginCallResult
+
+    func jsonPayload() -> String {
+        var errorDictionary: [String: Any] = [
+            "message": self.errorMessage,
+            "errorMessage": self.errorMessage
+        ]
+        errorDictionary["code"] = self.errorCode
+
+        do {
+            if let payload = try result.jsonRepresentation(includingFields: errorDictionary) {
+                CAPLog.print("ERROR MESSAGE: ", payload.prefix(512))
+                return payload
+            }
+        } catch PluginCallResult.SerializationError.invalidObject {
+            CAPLog.print("[Capacitor Plugin Error] - \(call.pluginId) - \(call.method) - Unable to serialize plugin response as JSON." +
+                            "Ensure that all data passed to success callback from module method is JSON serializable!")
+        } catch {
+            CAPLog.print("Unable to serialize plugin response as JSON: \(error.localizedDescription)")
+        }
+        return SerializationResult.empty.rawValue
+    }
+}
+
+internal extension JSResultError {
+    init(call: JSCall, callError: CAPPluginCallError) {
+        self.call = call
+        errorMessage = callError.message
+        errorDescription = callError.error?.localizedDescription ?? ""
+        errorCode = callError.code
+        result = callError.resultData ?? .dictionary([:])
+    }
+}

package/Capacitor/Capacitor/JSExport.swift

@@ -0,0 +1,218 @@
+internal struct PluginHeaderMethod: Codable {
+    let name: String
+    let rtype: String?
+}
+
+internal struct PluginHeader: Codable {
+    let name: String
+    let methods: [PluginHeaderMethod]
+}
+
+/**
+ JSExport handles defining JS APIs that map to registered plugins and are responsible for proxying calls to our bridge.
+ */
+internal class JSExport {
+    static let catchallOptionsParameter = "_options"
+    static let callbackParameter = "_callback"
+
+    static func exportCapacitorGlobalJS(userContentController: WKUserContentController, isDebug: Bool, loggingEnabled: Bool, localUrl: String) throws {
+        let data = "window.Capacitor = { DEBUG: \(isDebug), isLoggingEnabled: \(loggingEnabled), Plugins: {} }; window.WEBVIEW_SERVER_URL = '\(localUrl)';"
+        let userScript = WKUserScript(source: data, injectionTime: .atDocumentStart, forMainFrameOnly: true)
+        userContentController.addUserScript(userScript)
+    }
+
+    static func exportBridgeJS(userContentController: WKUserContentController) throws {
+        let capBundle = Bundle(for: Self.self)
+        guard let jsUrl = capBundle.url(forResource: "native-bridge", withExtension: "js") else {
+            CAPLog.print("ERROR: Required native-bridge.js file in Capacitor not found. Bridge will not function!")
+            throw CapacitorBridgeError.errorExportingCoreJS
+        }
+        do {
+            try self.injectFile(fileURL: jsUrl, userContentController: userContentController)
+        } catch {
+            CAPLog.print("ERROR: Unable to read required native-bridge.js file from the Capacitor framework. Bridge will not function!")
+            throw CapacitorBridgeError.errorExportingCoreJS
+        }
+    }
+
+    static func exportCordovaJS(userContentController: WKUserContentController) throws {
+        guard let cordovaUrl = Bundle.main.url(forResource: "public/cordova", withExtension: "js") else {
+            CAPLog.print("ERROR: Required cordova.js file not found. Cordova plugins will not function!")
+            throw CapacitorBridgeError.errorExportingCoreJS
+        }
+        guard let cordovaPluginsUrl = Bundle.main.url(forResource: "public/cordova_plugins", withExtension: "js") else {
+            CAPLog.print("ERROR: Required cordova_plugins.js file not found. Cordova plugins  will not function!")
+            throw CapacitorBridgeError.errorExportingCoreJS
+        }
+        do {
+            try self.injectFile(fileURL: cordovaUrl, userContentController: userContentController)
+            try self.injectFile(fileURL: cordovaPluginsUrl, userContentController: userContentController)
+        } catch {
+            CAPLog.print("ERROR: Unable to read required cordova files. Cordova plugins will not function!")
+            throw CapacitorBridgeError.errorExportingCoreJS
+        }
+    }
+
+    static func exportMiscFileJS(paths: [String], userContentController: WKUserContentController) {
+        for path in paths {
+            if let miscJSFilePath = Bundle.main.url(forResource: "public/\(path.replacingOccurrences(of: ".js", with: ""))", withExtension: "js") {
+                do {
+                    try self.injectFile(fileURL: miscJSFilePath, userContentController: userContentController)
+                } catch {
+                    CAPLog.print("WARNING: Unable to inject js from path \(miscJSFilePath)")
+                }
+            } else {
+                CAPLog.print("WARNING: Unable to inject js from path \(path)")
+            }
+        }
+    }
+
+    /**
+     Export the JS required to implement the given plugin.
+     */
+    static func exportJS(for plugin: CapacitorPlugin, in userContentController: WKUserContentController) {
+        var lines = [String]()
+
+        lines.append("""
+                    (function(w) {
+                    var a = (w.Capacitor = w.Capacitor || {});
+                    var p = (a.Plugins = a.Plugins || {});
+                    var t = (p['\(plugin.jsName)'] = {});
+                    t.addListener = function(eventName, callback) {
+                    return w.Capacitor.addListener('\(plugin.jsName)', eventName, callback);
+                    }
+                    t.removeAllListeners = function() {
+                    return w.Capacitor.nativePromise('\(plugin.jsName)', 'removeAllListeners');
+                    }
+                    """)
+
+        for method in plugin.pluginMethods {
+            lines.append(generateMethod(pluginClassName: plugin.jsName, method: method))
+        }
+
+        lines.append("""
+            })(window);
+            """)
+        if let data = try? JSONEncoder().encode(createPluginHeader(for: plugin)),
+           let header = String(data: data, encoding: .utf8) {
+            lines.append("""
+                (function(w) {
+                var a = (w.Capacitor = w.Capacitor || {});
+                var h = (a.PluginHeaders = a.PluginHeaders || []);
+                h.push(\(header));
+                })(window);
+                """)
+        }
+        let js = lines.joined(separator: "\n")
+        let userScript = WKUserScript(source: js, injectionTime: .atDocumentStart, forMainFrameOnly: true)
+        userContentController.addUserScript(userScript)
+    }
+
+    private static func createPluginHeader(for plugin: CapacitorPlugin) -> PluginHeader? {
+        let methods = [
+            PluginHeaderMethod(name: "addListener", rtype: nil),
+            PluginHeaderMethod(name: "removeListener", rtype: nil),
+            PluginHeaderMethod(name: "removeAllListeners", rtype: "promise"),
+            PluginHeaderMethod(name: "checkPermissions", rtype: "promise"),
+            PluginHeaderMethod(name: "requestPermissions", rtype: "promise")
+        ]
+
+        return PluginHeader(
+            name: plugin.jsName,
+            methods: methods + plugin.pluginMethods.map(createPluginHeaderMethod)
+        )
+
+    }
+
+    private static func createPluginHeaderMethod(method: CAPPluginMethod) -> PluginHeaderMethod {
+        var rtype = method.returnType
+        if rtype == "none" {
+            rtype = nil
+        }
+        return PluginHeaderMethod(name: method.name, rtype: rtype)
+    }
+
+    private static func generateMethod(pluginClassName: String, method: CAPPluginMethod) -> String {
+        let methodName = method.name!
+        let returnType = method.returnType!
+        var paramList = [String]()
+
+        // add the catch-all
+        // options argument which takes a full object and converts each
+        // key/value pair into an option for plugin call.
+        paramList.append(catchallOptionsParameter)
+
+        // Automatically add the _callback param if returning data through a callback
+        if returnType == CAPPluginReturnCallback {
+            paramList.append(callbackParameter)
+        }
+
+        // Create a param string of the form "param1, param2, param3"
+        let paramString = paramList.joined(separator: ", ")
+
+        // Generate the argument object that will be sent on each call
+        let argObjectString = catchallOptionsParameter
+
+        var lines = [String]()
+
+        // Create the function declaration
+        lines.append("t['\(method.name!)'] = function(\(paramString)) {")
+
+        // Create the call to Capacitor ...
+        if returnType == CAPPluginReturnNone {
+            // ...using none
+            lines.append("""
+                    return w.Capacitor.nativeCallback('\(pluginClassName)', '\(methodName)', \(argObjectString));
+                    """)
+        } else if returnType == CAPPluginReturnPromise {
+
+            // ...using a promise
+            lines.append("""
+                    return w.Capacitor.nativePromise('\(pluginClassName)', '\(methodName)', \(argObjectString));
+                    """)
+        } else if returnType == CAPPluginReturnCallback {
+            // ...using a callback
+            lines.append("""
+                    return w.Capacitor.nativeCallback('\(pluginClassName)', '\(methodName)', \(argObjectString), \(callbackParameter));
+                    """)
+        } else {
+            CAPLog.print("Error: plugin method return type \(returnType) is not supported!")
+        }
+
+        // Close the function
+        lines.append("}")
+        return lines.joined(separator: "\n")
+    }
+
+    static func exportCordovaPluginsJS(userContentController: WKUserContentController) throws {
+        if let pluginsJSFolder = Bundle.main.url(forResource: "public/plugins", withExtension: nil) {
+            self.injectFilesForFolder(folder: pluginsJSFolder, userContentController: userContentController)
+        }
+    }
+
+    static func injectFilesForFolder(folder: URL, userContentController: WKUserContentController) {
+        let fileManager = FileManager.default
+        do {
+            let fileURLs = try fileManager.contentsOfDirectory(at: folder, includingPropertiesForKeys: nil, options: [])
+            for fileURL in fileURLs {
+                if fileURL.hasDirectoryPath {
+                    injectFilesForFolder(folder: fileURL, userContentController: userContentController)
+                } else {
+                    try self.injectFile(fileURL: fileURL, userContentController: userContentController)
+                }
+            }
+        } catch {
+            CAPLog.print("Error while enumerating files")
+        }
+    }
+
+    static func injectFile(fileURL: URL, userContentController: WKUserContentController) throws {
+        do {
+            let data = try String(contentsOf: fileURL, encoding: .utf8)
+            let userScript = WKUserScript(source: data, injectionTime: .atDocumentStart, forMainFrameOnly: true)
+            userContentController.addUserScript(userScript)
+        } catch {
+            CAPLog.print("Unable to inject js file")
+        }
+    }
+}

package/Capacitor/Capacitor/JSTypes.swift

@@ -0,0 +1,254 @@
+import Foundation
+
+// declare our empty protocol, and conformance, for typing
+public protocol JSValue {}
+extension String: JSValue {}
+extension Bool: JSValue {}
+extension Int: JSValue {}
+extension Float: JSValue {}
+extension Double: JSValue {}
+extension NSNumber: JSValue {}
+extension NSNull: JSValue {}
+extension Array: JSValue {}
+extension Date: JSValue {}
+extension Dictionary: JSValue where Key == String, Value == JSValue {}
+
+// convenience aliases
+public typealias JSObject = [String: JSValue]
+public typealias JSArray = [JSValue]
+
+// string types
+public protocol JSStringContainer {
+    func getString(_ key: String, _ defaultValue: String) -> String
+    func getString(_ key: String) -> String?
+}
+
+extension JSStringContainer {
+    public func getString(_ key: String, _ defaultValue: String) -> String {
+        return getString(key) ?? defaultValue
+    }
+}
+
+// boolean types
+public protocol JSBoolContainer {
+    func getBool(_ key: String, _ defaultValue: Bool) -> Bool
+    func getBool(_ key: String) -> Bool?
+}
+
+extension JSBoolContainer {
+    public func getBool(_ key: String, _ defaultValue: Bool) -> Bool {
+        return getBool(key) ?? defaultValue
+    }
+}
+
+// integer types
+public protocol JSIntContainer {
+    func getInt(_ key: String, _ defaultValue: Int) -> Int
+    func getInt(_ key: String) -> Int?
+}
+
+extension JSIntContainer {
+    public func getInt(_ key: String, _ defaultValue: Int) -> Int {
+        return getInt(key) ?? defaultValue
+    }
+}
+
+// float types
+public protocol JSFloatContainer {
+    func getFloat(_ key: String, _ defaultValue: Float) -> Float
+    func getFloat(_ key: String) -> Float?
+}
+
+extension JSFloatContainer {
+    public func getFloat(_ key: String, _ defaultValue: Float) -> Float {
+        return getFloat(key) ?? defaultValue
+    }
+}
+
+// double types
+public protocol JSDoubleContainer {
+    func getDouble(_ key: String, _ defaultValue: Double) -> Double
+    func getDouble(_ key: String) -> Double?
+}
+
+extension JSDoubleContainer {
+    public func getDouble(_ key: String, _ defaultValue: Double) -> Double {
+        return getDouble(key) ?? defaultValue
+    }
+}
+
+// date types
+public protocol JSDateContainer {
+    func getDate(_ key: String, _ defaultValue: Date) -> Date
+    func getDate(_ key: String) -> Date?
+}
+
+extension JSDateContainer {
+    public func getDate(_ key: String, _ defaultValue: Date) -> Date {
+        return getDate(key) ?? defaultValue
+    }
+}
+
+// array types
+public protocol JSArrayContainer {
+    func getArray(_ key: String, _ defaultValue: JSArray) -> JSArray
+    func getArray<T>(_ key: String, _ ofType: T.Type) -> [T]?
+    func getArray(_ key: String) -> JSArray?
+}
+
+extension JSArrayContainer {
+    public func getArray(_ key: String, _ defaultValue: JSArray) -> JSArray {
+        return getArray(key) ?? defaultValue
+    }
+
+    public func getArray<T>(_ key: String, _ ofType: T.Type) -> [T]? {
+        return getArray(key) as? [T]
+    }
+}
+
+// dictionary types
+public protocol JSObjectContainer {
+    func getObject(_ key: String, _ defaultValue: JSObject) -> JSObject
+    func getObject(_ key: String) -> JSObject?
+}
+
+extension JSObjectContainer {
+    public func getObject(_ key: String, _ defaultValue: JSObject) -> JSObject {
+        return getObject(key) ?? defaultValue
+    }
+}
+
+public protocol JSValueContainer: JSStringContainer, JSBoolContainer, JSIntContainer, JSFloatContainer,
+                                  JSDoubleContainer, JSDateContainer, JSArrayContainer, JSObjectContainer {
+    static var jsDateFormatter: ISO8601DateFormatter { get }
+    var jsObjectRepresentation: JSObject { get }
+}
+
+extension JSValueContainer {
+    public func getValue(_ key: String) -> JSValue? {
+        return jsObjectRepresentation[key]
+    }
+
+    @available(*, message: "All values returned conform to JSValue, use getValue(_:) instead.", renamed: "getValue(_:)")
+    public func getAny(_ key: String) -> Any? {
+        return getValue(key)
+    }
+
+    public func getString(_ key: String) -> String? {
+        return jsObjectRepresentation[key] as? String
+    }
+
+    public func getBool(_ key: String) -> Bool? {
+        return jsObjectRepresentation[key] as? Bool
+    }
+
+    public func getInt(_ key: String) -> Int? {
+        return jsObjectRepresentation[key] as? Int
+    }
+
+    public func getFloat(_ key: String) -> Float? {
+        if let floatValue = jsObjectRepresentation[key] as? Float {
+            return floatValue
+        } else if let doubleValue = jsObjectRepresentation[key] as? Double {
+            return Float(doubleValue)
+        }
+        return nil
+    }
+
+    public func getDouble(_ key: String) -> Double? {
+        return jsObjectRepresentation[key] as? Double
+    }
+
+    public func getDate(_ key: String) -> Date? {
+        if let isoString = jsObjectRepresentation[key] as? String {
+            return Self.jsDateFormatter.date(from: isoString)
+        }
+        return jsObjectRepresentation[key] as? Date
+    }
+
+    public func getArray(_ key: String) -> JSArray? {
+        return jsObjectRepresentation[key] as? JSArray
+    }
+
+    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 {
+    static var jsDateFormatter: ISO8601DateFormatter { get }
+    var dictionaryRepresentation: NSDictionary { get }
+}
+
+/*
+ Simply casting objects from foundation class clusters (such as __NSArrayM)
+ doesn't work with the JSValue protocol and will always fail. So we need to
+ recursively and explicitly convert each value in the dictionary.
+ */
+public enum JSTypes {}
+extension JSTypes {
+    public static func coerceDictionaryToJSObject(_ dictionary: NSDictionary?, formattingDatesAsStrings: Bool = false) -> JSObject? {
+        return coerceToJSValue(dictionary, formattingDates: formattingDatesAsStrings) as? JSObject
+    }
+
+    public static func coerceDictionaryToJSObject(_ dictionary: [AnyHashable: Any]?, formattingDatesAsStrings: Bool = false) -> JSObject? {
+        return coerceToJSValue(dictionary, formattingDates: formattingDatesAsStrings) as? JSObject
+    }
+
+    public static func coerceArrayToJSArray(_ array: [Any]?, formattingDatesAsStrings: Bool = false) -> JSArray? {
+        return array?.compactMap { coerceToJSValue($0, formattingDates: formattingDatesAsStrings) }
+    }
+}
+
+private let dateStringFormatter = ISO8601DateFormatter()
+
+// We need a large switch statement because we have a lot of types.
+// swiftlint:disable:next cyclomatic_complexity
+private func coerceToJSValue(_ value: Any?, formattingDates: Bool) -> JSValue? {
+    guard let value = value else {
+        return nil
+    }
+    switch value {
+    case let stringValue as String:
+        return stringValue
+    case let numberValue as NSNumber:
+        return numberValue
+    case let boolValue as Bool:
+        return boolValue
+    case let intValue as Int:
+        return intValue
+    case let floatValue as Float:
+        return floatValue
+    case let doubleValue as Double:
+        return doubleValue
+    case let dateValue as Date:
+        if formattingDates {
+            return dateStringFormatter.string(from: dateValue)
+        }
+        return dateValue
+    case let nullValue as NSNull:
+        return nullValue
+    case let arrayValue as NSArray:
+        return arrayValue.compactMap { coerceToJSValue($0, formattingDates: formattingDates) }
+    case let dictionaryValue as NSDictionary:
+        let keys = dictionaryValue.allKeys.compactMap { $0 as? String }
+        var result: JSObject = [:]
+        for key in keys {
+            result[key] = coerceToJSValue(dictionaryValue[key], formattingDates: formattingDates)
+        }
+        return result
+    default:
+        return nil
+    }
+}

package/Capacitor/Capacitor/KeyPath.swift

@@ -0,0 +1,60 @@
+import Foundation
+
+public struct KeyPath {
+    var segments: [String]
+    var isEmpty: Bool { return segments.isEmpty }
+    var path: String {
+        return segments.joined(separator: ".")
+    }
+
+    // initializers
+    init(_ string: String) {
+        self.segments = string.components(separatedBy: ".")
+    }
+
+    init(segments: [String]) {
+        self.segments = segments
+    }
+
+    // returns a tuple of the first segment and the remaining key path. result is nil if the key path has no segments.
+    func headAndRemainder() -> (head: String, remainder: KeyPath)? {
+        guard !isEmpty else {
+            return nil
+        }
+        var paths = segments
+        let head = paths.removeFirst()
+        return (head, KeyPath(segments: paths))
+    }
+}
+
+extension KeyPath: ExpressibleByStringLiteral {
+    public init(stringLiteral value: String) {
+        self.init(value)
+    }
+
+    public init(unicodeScalarLiteral value: String) {
+        self.init(value)
+    }
+
+    public init(extendedGraphemeClusterLiteral value: String) {
+        self.init(value)
+    }
+}
+
+extension JSObject {
+    public subscript(keyPath keyPath: KeyPath) -> JSValue? {
+        switch keyPath.headAndRemainder() {
+        case nil: // path is empty
+            return nil
+        case let (head, remainder)? where remainder.isEmpty: // reached the end of the path
+            return self[head]
+        case let (head, remainder)?: // we have at least one level to traverse
+            switch self[head] {
+            case let childObject as JSObject: // iterate down the next level
+                return childObject[keyPath: remainder]
+            default: // not an object, can't go any deeper
+                return nil
+            }
+        }
+    }
+}