@capawesome/capacitor-square-mobile-payments 0.0.1

package/ios/Plugin/SquareMobilePaymentsHelper.swift

@@ -0,0 +1,212 @@
+import Foundation
+import Capacitor
+import SquareMobilePaymentsSDK
+
+public class SquareMobilePaymentsHelper {
+
+    // MARK: - Currency Conversion
+
+    public static func convertToCurrency(_ code: String) -> SquareMobilePaymentsSDK.Currency {
+        switch code.uppercased() {
+        case "USD": return .USD
+        case "CAD": return .CAD
+        case "AUD": return .AUD
+        case "GBP": return .GBP
+        case "EUR": return .EUR
+        case "JPY": return .JPY
+        default: return .USD
+        }
+    }
+
+    // MARK: - ProcessingMode Conversion
+
+    public static func convertToProcessingMode(_ mode: String?) -> SquareMobilePaymentsSDK.ProcessingMode {
+        guard let mode = mode else {
+            return .autoDetect
+        }
+
+        switch mode.uppercased() {
+        case "AUTO_DETECT": return .autoDetect
+        case "ONLINE_ONLY": return .onlineOnly
+        case "OFFLINE_ONLY": return .offlineOnly
+        default: return .autoDetect
+        }
+    }
+
+    // MARK: - PromptMode Conversion
+
+    public static func convertToPromptMode(_ mode: String?) -> SquareMobilePaymentsSDK.PromptMode {
+        guard let mode = mode else {
+            return .default
+        }
+
+        switch mode.uppercased() {
+        case "DEFAULT": return .default
+        case "CUSTOM": return .custom
+        default: return .default
+        }
+    }
+
+    // MARK: - AdditionalMethods Conversion
+
+    public static func convertToAdditionalMethods(_ methods: [String]?) -> SquareMobilePaymentsSDK.AdditionalPaymentMethods {
+        guard let methods = methods, !methods.isEmpty else {
+            return AdditionalPaymentMethods()
+        }
+
+        var methodsArray: [AdditionalPaymentMethods] = []
+
+        for method in methods {
+            switch method.uppercased() {
+            case "KEYED": methodsArray.append(.keyed)
+            case "CASH": methodsArray.append(.cash)
+            default: break
+            }
+        }
+
+        return AdditionalPaymentMethods(methodsArray)
+    }
+
+    // MARK: - DelayAction Conversion
+
+    public static func convertToDelayAction(_ action: String?) -> SquareMobilePaymentsSDK.DelayAction? {
+        guard let action = action else {
+            return nil
+        }
+
+        switch action.uppercased() {
+        case "COMPLETE": return .complete
+        case "CANCEL": return .cancel
+        default: return nil
+        }
+    }
+
+    // MARK: - Reader Model Conversion
+
+    public static func convertReaderModel(_ model: SquareMobilePaymentsSDK.ReaderModel) -> String {
+        switch model {
+        case .contactlessAndChip: return "CONTACTLESS_AND_CHIP"
+        case .magstripe: return "MAGSTRIPE"
+        case .stand: return "STAND"
+        @unknown default: return "UNKNOWN"
+        }
+    }
+
+    // MARK: - Reader Status Conversion
+
+    public static func convertReaderStatus(_ status: SquareMobilePaymentsSDK.ReaderStatus) -> String {
+        switch status {
+        case .ready: return "READY"
+        case .connectingToSquare: return "CONNECTING_TO_SQUARE"
+        case .connectingToDevice: return "CONNECTING_TO_DEVICE"
+        case .faulty: return "FAULTY"
+        case .readerUnavailable: return "READER_UNAVAILABLE"
+        @unknown default: return "READER_UNAVAILABLE"
+        }
+    }
+
+    // MARK: - Reader Change Conversion
+
+    public static func convertReaderChange(_ change: SquareMobilePaymentsSDK.ReaderChange) -> String {
+        switch change {
+        case .batteryDidBeginCharging: return "BATTERY_DID_BEGIN_CHARGING"
+        case .batteryDidEndCharging: return "BATTERY_DID_END_CHARGING"
+        case .batteryLevelDidChange: return "BATTERY_LEVEL_DID_CHANGE"
+        case .readerStatusDidChange: return "STATUS_DID_CHANGE"
+        @unknown default: return "STATUS_DID_CHANGE"
+        }
+    }
+
+    // MARK: - Unavailable Reason Conversion
+
+    public static func convertUnavailableReason(_ reason: SquareMobilePaymentsSDK.ReaderUnavailableReason) -> String {
+        switch reason {
+        case .bluetoothFailure: return "BLUETOOTH_ERROR"
+        case .blockingFirmwareUpdate: return "FIRMWARE_UPDATE"
+        case .internalError: return "UNKNOWN"
+        @unknown default: return "UNKNOWN"
+        }
+    }
+
+    // MARK: - Card Input Method Conversion
+
+    public static func convertCardInputMethods(_ methods: SquareMobilePaymentsSDK.CardInputMethods) -> [String] {
+        var result: [String] = []
+
+        if methods.contains(.contactless) { result.append("TAP") }
+        if methods.contains(.chip) { result.append("DIP") }
+        if methods.contains(.swipe) { result.append("SWIPE") }
+
+        return result
+    }
+
+    public static func convertCardInputMethodFromString(_ methodString: String?) -> String {
+        guard let methodString = methodString else {
+            return "TAP"
+        }
+
+        let upperMethod = methodString.uppercased()
+        if upperMethod.contains("CONTACTLESS") || upperMethod.contains("TAP") {
+            return "TAP"
+        } else if upperMethod.contains("CHIP") || upperMethod.contains("DIP") || upperMethod.contains("EMV") {
+            return "DIP"
+        } else if upperMethod.contains("SWIPE") || upperMethod.contains("MAG") {
+            return "SWIPE"
+        } else if upperMethod.contains("KEYED") || upperMethod.contains("MANUAL") {
+            return "KEYED"
+        }
+        return "TAP"
+    }
+
+    // MARK: - Card Brand Conversion
+
+    public static func convertCardBrand(_ brand: SquareMobilePaymentsSDK.CardBrand) -> String {
+        switch brand {
+        case .visa: return "VISA"
+        case .mastercard: return "MASTERCARD"
+        case .americanExpress: return "AMERICAN_EXPRESS"
+        case .discover: return "DISCOVER"
+        case .discoverDiners: return "DISCOVER_DINERS"
+        case .jcb: return "JCB"
+        case .chinaUnionPay: return "UNION_PAY"
+        case .interac: return "INTERAC"
+        case .eftpos: return "EFTPOS"
+        case .unknown: return "OTHER"
+        @unknown default: return "OTHER"
+        }
+    }
+
+    // MARK: - Payment Type Conversion
+
+    public static func convertPaymentType(_ payment: SquareMobilePaymentsSDK.Payment) -> String {
+        if payment is SquareMobilePaymentsSDK.OnlinePayment {
+            return "ONLINE"
+        } else if payment is SquareMobilePaymentsSDK.OfflinePayment {
+            return "OFFLINE"
+        }
+        return "ONLINE"
+    }
+
+    // MARK: - Payment Status Conversion
+
+    public static func convertPaymentStatus(_ status: SquareMobilePaymentsSDK.PaymentStatus) -> String {
+        switch status {
+        case .completed: return "COMPLETED"
+        case .approved: return "APPROVED"
+        case .canceled: return "CANCELED"
+        case .failed: return "FAILED"
+        case .pending: return "PENDING"
+        @unknown default: return "PENDING"
+        }
+    }
+
+    // MARK: - Environment Conversion
+
+    public static func convertEnvironment(_ environment: SquareMobilePaymentsSDK.Environment) -> String {
+        switch environment {
+        case .production: return "production"
+        case .sandbox: return "sandbox"
+        @unknown default: return "production"
+        }
+    }
+}

package/ios/Plugin/SquareMobilePaymentsPlugin.swift

@@ -0,0 +1,347 @@
+import Foundation
+import Capacitor
+
+/**
+ * Please read the Capacitor iOS Plugin Development Guide
+ * here: https://capacitorjs.com/docs/plugins/ios
+ */
+@objc(SquareMobilePaymentsPlugin)
+public class SquareMobilePaymentsPlugin: CAPPlugin, CAPBridgedPlugin {
+    public static let tag = "SquareMobilePayments"
+
+    public let identifier = "SquareMobilePaymentsPlugin"
+    public let jsName = "SquareMobilePayments"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "initialize", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "authorize", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isAuthorized", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "deauthorize", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "showSettings", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getSettings", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startPairing", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopPairing", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isPairingInProgress", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getReaders", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "forgetReader", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "retryConnection", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startPayment", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "cancelPayment", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getAvailableCardInputMethods", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "checkPermissions", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestPermissions", returnType: CAPPluginReturnPromise)
+    ]
+
+    public static let permissionLocation = "location"
+    public static let permissionBluetooth = "bluetooth"
+
+    private var implementation: SquareMobilePayments?
+
+    override public func load() {
+        self.implementation = SquareMobilePayments(plugin: self)
+    }
+
+    @objc func initialize(_ call: CAPPluginCall) {
+        do {
+            let options = try InitializeOptions(call)
+
+            try implementation?.initialize(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func authorize(_ call: CAPPluginCall) {
+        do {
+            let options = try AuthorizeOptions(call)
+
+            try implementation?.authorize(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func isAuthorized(_ call: CAPPluginCall) {
+        do {
+            try implementation?.isAuthorized(completion: { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call, result)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func deauthorize(_ call: CAPPluginCall) {
+        do {
+            try implementation?.deauthorize(completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func showSettings(_ call: CAPPluginCall) {
+        do {
+            try implementation?.showSettings(completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func getSettings(_ call: CAPPluginCall) {
+        do {
+            try implementation?.getSettings(completion: { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call, result)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func startPairing(_ call: CAPPluginCall) {
+        do {
+            try implementation?.startPairing(completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func stopPairing(_ call: CAPPluginCall) {
+        do {
+            try implementation?.stopPairing(completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func isPairingInProgress(_ call: CAPPluginCall) {
+        do {
+            try implementation?.isPairingInProgress(completion: { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call, result)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func getReaders(_ call: CAPPluginCall) {
+        do {
+            try implementation?.getReaders(completion: { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call, result)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func forgetReader(_ call: CAPPluginCall) {
+        do {
+            let options = try ForgetReaderOptions(call)
+
+            try implementation?.forgetReader(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func retryConnection(_ call: CAPPluginCall) {
+        do {
+            let options = try RetryConnectionOptions(call)
+
+            try implementation?.retryConnection(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func startPayment(_ call: CAPPluginCall) {
+        do {
+            let options = try StartPaymentOptions(call)
+
+            try implementation?.startPayment(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func cancelPayment(_ call: CAPPluginCall) {
+        do {
+            try implementation?.cancelPayment(completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func getAvailableCardInputMethods(_ call: CAPPluginCall) {
+        do {
+            try implementation?.getAvailableCardInputMethods(completion: { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call, result)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc override public func checkPermissions(_ call: CAPPluginCall) {
+        var locationResult: String
+        switch implementation?.checkLocationPermission() {
+        case .notDetermined:
+            locationResult = "prompt"
+        case .none, .restricted, .denied:
+            locationResult = "denied"
+        case .authorizedAlways, .authorizedWhenInUse:
+            locationResult = "granted"
+        @unknown default:
+            locationResult = "prompt"
+        }
+
+        var bluetoothResult: String
+        switch implementation?.checkBluetoothPermission() {
+        case .notDetermined:
+            bluetoothResult = "prompt"
+        case .none, .restricted, .denied:
+            bluetoothResult = "denied"
+        case .allowedAlways:
+            bluetoothResult = "granted"
+        @unknown default:
+            bluetoothResult = "prompt"
+        }
+
+        var result = JSObject()
+        result[SquareMobilePaymentsPlugin.permissionLocation] = locationResult
+        result[SquareMobilePaymentsPlugin.permissionBluetooth] = bluetoothResult
+        call.resolve(result)
+    }
+
+    @objc override public func requestPermissions(_ call: CAPPluginCall) {
+        if !hasUsageDescription(forKey: "NSLocationWhenInUseUsageDescription") {
+            rejectCall(call, CustomError.privacyDescriptionsMissing)
+            return
+        }
+        if !hasUsageDescription(forKey: "NSBluetoothAlwaysUsageDescription") {
+            rejectCall(call, CustomError.privacyDescriptionsMissing)
+            return
+        }
+
+        let group = DispatchGroup()
+
+        if implementation?.checkLocationPermission() == .notDetermined {
+            group.enter()
+            implementation?.requestLocationPermission { _ in
+                group.leave()
+            }
+        }
+
+        if implementation?.checkBluetoothPermission() == .notDetermined {
+            group.enter()
+            implementation?.requestBluetoothPermission {
+                group.leave()
+            }
+        }
+
+        group.notify(queue: DispatchQueue.main) {
+            self.checkPermissions(call)
+        }
+    }
+
+    // MARK: - Helper Methods
+
+    private func hasUsageDescription(forKey key: String) -> Bool {
+        return Bundle.main.object(forInfoDictionaryKey: key) is String
+    }
+
+    private func rejectCall(_ call: CAPPluginCall, _ error: Error) {
+        CAPLog.print("[", SquareMobilePaymentsPlugin.tag, "] ", error)
+        call.reject(error.localizedDescription)
+    }
+
+    private func resolveCall(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    private func resolveCall<T: Result>(_ call: CAPPluginCall, _ result: T?) {
+        if let result = result?.toJSObject() as? JSObject {
+            call.resolve(result)
+        } else {
+            call.resolve()
+        }
+    }
+}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@capawesome/capacitor-square-mobile-payments",
+  "version": "0.0.1",
+  "description": "Unofficial Capacitor plugin for Square Mobile Payments SDK.",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Plugin/",
+    "CapawesomeCapacitorSquareMobilePayments.podspec",
+    "Package.swift"
+  ],
+  "author": "Robin Genz <mail@robingenz.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/capawesome-team/capacitor-plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/capawesome-team/capacitor-plugins/issues"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/capawesome-team/"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/capawesome"
+    }
+  ],
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin -destination generic/platform=iOS && cd ..",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\"",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api SquareMobilePaymentsPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "ios:pod:install": "cd ios && pod install --repo-update && cd ..",
+    "ios:spm:install": "cd ios && swift package resolve && cd ..",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "8.0.0",
+    "@capacitor/cli": "8.0.0",
+    "@capacitor/core": "8.0.0",
+    "@capacitor/docgen": "0.3.1",
+    "@capacitor/ios": "8.0.0",
+    "@ionic/eslint-config": "0.4.0",
+    "@ionic/swiftlint-config": "2.0.0",
+    "eslint": "8.57.0",
+    "prettier": "3.4.2",
+    "prettier-plugin-java": "2.6.7",
+    "rimraf": "6.1.2",
+    "rollup": "4.53.3",
+    "swiftlint": "2.0.0",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}