@gmisoftware/react-native-pay 0.0.4

package/android/src/main/java/com/margelo/nitro/pay/PaymentMapper.kt

@@ -0,0 +1,89 @@
+package com.margelo.nitro.pay
+
+import com.google.android.gms.wallet.PaymentData
+import org.json.JSONException
+import org.json.JSONObject
+import java.util.UUID
+
+/**
+ * Mapper for converting between Google Pay and app payment types
+ */
+object PaymentMapper {
+    
+    /**
+     * Maps Google Pay PaymentData to PaymentResult
+     */
+    fun mapPaymentDataToResult(paymentData: PaymentData): PaymentResult {
+        return try {
+            val paymentInfo = paymentData.toJson()
+            val paymentMethodData = JSONObject(paymentInfo).getJSONObject("paymentMethodData")
+            
+            // Extract token
+            val tokenData = paymentMethodData.getJSONObject("tokenizationData")
+            val token = tokenData.getString("token")
+            
+            // Extract payment method info
+            val info = paymentMethodData.getJSONObject("info")
+            val cardNetwork = info.optString("cardNetwork", "unknown")
+            val cardDetails = info.optString("cardDetails", "****")
+            
+            // Create payment method
+            val paymentMethod = PaymentMethod(
+                displayName = "$cardNetwork $cardDetails",
+                network = mapCardNetwork(cardNetwork),
+                type = PaymentMethodType.UNKNOWN,
+                secureElementPass = null,
+                billingAddress = null
+            )
+            
+            // Create payment token
+            val paymentToken = PaymentToken(
+                paymentMethod = paymentMethod,
+                transactionIdentifier = UUID.randomUUID().toString(),
+                paymentData = token
+            )
+            
+            // Create successful result
+            PaymentResult(
+                success = true,
+                transactionId = UUID.randomUUID().toString(),
+                token = paymentToken,
+                error = null
+            )
+        } catch (e: JSONException) {
+            createErrorResult("Failed to parse payment data: ${e.message}")
+        }
+    }
+    
+    /**
+     * Maps card network string to PaymentNetwork enum
+     */
+    fun mapCardNetwork(network: String): PaymentNetwork {
+        return when (network.uppercase()) {
+            "VISA" -> PaymentNetwork.VISA
+            "MASTERCARD" -> PaymentNetwork.MASTERCARD
+            "AMEX" -> PaymentNetwork.AMEX
+            "DISCOVER" -> PaymentNetwork.DISCOVER
+            "JCB" -> PaymentNetwork.JCB
+            "MAESTRO" -> PaymentNetwork.MAESTRO
+            "ELECTRON" -> PaymentNetwork.ELECTRON
+            "ELO" -> PaymentNetwork.ELO
+            "INTERAC" -> PaymentNetwork.INTERAC
+            else -> PaymentNetwork.VISA // Default fallback
+        }
+    }
+    
+    /**
+     * Creates an error PaymentResult
+     */
+    fun createErrorResult(errorMessage: String): PaymentResult {
+        return PaymentResult(
+            success = false,
+            transactionId = null,
+            token = null,
+            error = errorMessage
+        )
+    }
+}
+
+

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./lib/plugin/index.js')

package/ios/ApplePayButtonFactory.swift

@@ -0,0 +1,53 @@
+import UIKit
+import PassKit
+
+// MARK: - Button Type Mapping
+
+enum ApplePayButtonFactory {
+    
+    /// Maps ApplePayButtonType to PKPaymentButtonType
+    static func mapButtonType(_ type: ApplePayButtonType) -> PKPaymentButtonType {
+        switch type {
+        case .buy: return .buy
+        case .setup: return .setUp
+        case .book: return .book
+        case .donate: return .donate
+        case .continue: return .continue
+        case .reload: return .reload
+        case .addmoney: return .addMoney
+        case .topup: return .topUp
+        case .order: return .order
+        case .rent: return .rent
+        case .support: return .support
+        case .contribute: return .contribute
+        case .tip: return .tip
+        }
+    }
+    
+    /// Maps ApplePayButtonStyle to PKPaymentButtonStyle
+    static func mapButtonStyle(_ style: ApplePayButtonStyle) -> PKPaymentButtonStyle {
+        switch style {
+        case .white: return .white
+        case .whiteoutline: return .whiteOutline
+        case .black: return .black
+        default: return .automatic
+        }
+    }
+    
+    /// Creates a configured PKPaymentButton
+    static func createButton(
+        type: ApplePayButtonType,
+        style: ApplePayButtonStyle,
+        target: Any?,
+        action: Selector
+    ) -> PKPaymentButton {
+        let pkButtonType = mapButtonType(type)
+        let pkButtonStyle = mapButtonStyle(style)
+        let button = PKPaymentButton(paymentButtonType: pkButtonType, paymentButtonStyle: pkButtonStyle)
+        button.addTarget(target, action: action, for: .touchUpInside)
+        button.translatesAutoresizingMaskIntoConstraints = false
+        return button
+    }
+}
+
+

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  NitroPay
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once

package/ios/HybridApplePayButton.swift

@@ -0,0 +1,60 @@
+import UIKit
+import PassKit
+
+/**
+ * Hybrid implementation of ApplePayButton view component
+ */
+class HybridApplePayButton: HybridApplePayButtonSpec {
+    
+    // Props
+    var buttonType: ApplePayButtonType = .buy
+    var buttonStyle: ApplePayButtonStyle = .black
+    var onPress: (() -> Void)?
+    
+    // View
+    var view: UIView = UIView()
+    
+    // Internal state
+    private var paymentButton: PKPaymentButton?
+    
+    override init() {
+        super.init()
+        setupButton()
+    }
+    
+    func afterUpdate() {
+        setupButton()
+    }
+    
+    // MARK: - Private Methods
+    
+    private func setupButton() {
+        // Remove existing button if any
+        paymentButton?.removeFromSuperview()
+        
+        // Create new button
+        let button = ApplePayButtonFactory.createButton(
+            type: buttonType,
+            style: buttonStyle,
+            target: self,
+            action: #selector(buttonPressed)
+        )
+        
+        paymentButton = button
+        
+        // Add to view
+        view.addSubview(button)
+        
+        // Set up constraints to fill the view
+        NSLayoutConstraint.activate([
+            button.topAnchor.constraint(equalTo: view.topAnchor),
+            button.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            button.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            button.bottomAnchor.constraint(equalTo: view.bottomAnchor)
+        ])
+    }
+    
+    @objc private func buttonPressed() {
+        onPress?()
+    }
+}

package/ios/HybridPaymentHandler.swift

@@ -0,0 +1,248 @@
+import PassKit
+import UIKit
+import NitroModules
+
+// MARK: - Constants
+
+private enum ErrorMessage {
+    static let paymentCancelled = "Payment cancelled by user"
+    static let unableToPresent = "Unable to present payment authorization"
+    static let unableToCreate = "Unable to create payment authorization"
+}
+
+// MARK: - Payment Request Builder
+
+private struct PaymentRequestBuilder {
+    
+    static func build(from request: PaymentRequest) -> PKPaymentRequest {
+        let paymentRequest = PKPaymentRequest()
+        
+        paymentRequest.merchantIdentifier = request.merchantIdentifier
+        paymentRequest.countryCode = request.countryCode
+        paymentRequest.currencyCode = request.currencyCode
+        paymentRequest.paymentSummaryItems = buildPaymentItems(request.paymentItems)
+        paymentRequest.merchantCapabilities = buildMerchantCapabilities(request.merchantCapabilities)
+        paymentRequest.supportedNetworks = buildSupportedNetworks(request.supportedNetworks)
+        
+        if let shippingType = request.shippingType {
+            paymentRequest.shippingType = convertShippingType(shippingType)
+        }
+        
+        configureContactRequirements(paymentRequest, request: request)
+        
+        return paymentRequest
+    }
+    
+    private static func buildPaymentItems(_ items: [PaymentItem]) -> [PKPaymentSummaryItem] {
+        return items.map { item in
+            let pkItem = PKPaymentSummaryItem(
+                label: item.label,
+                amount: NSDecimalNumber(decimal: Decimal(item.amount))
+            )
+            pkItem.type = item.type == .final ? .final : .pending
+            return pkItem
+        }
+    }
+    
+    private static func buildMerchantCapabilities(_ capabilities: [String]) -> PKMerchantCapability {
+        var merchantCapabilities: PKMerchantCapability = []
+        for capability in capabilities {
+            switch capability {
+            case "3DS": merchantCapabilities.insert(.capability3DS)
+            case "EMV": merchantCapabilities.insert(.capabilityEMV)
+            case "Credit": merchantCapabilities.insert(.capabilityCredit)
+            case "Debit": merchantCapabilities.insert(.capabilityDebit)
+            default: break
+            }
+        }
+        return merchantCapabilities
+    }
+    
+    private static func buildSupportedNetworks(_ networks: [String]) -> [PKPaymentNetwork] {
+        return networks.compactMap { PassKitTypeMapper.convertToPKPaymentNetwork($0) }
+    }
+    
+    private static func convertShippingType(_ type: String) -> PKShippingType {
+        switch type {
+        case "shipping": return .shipping
+        case "delivery": return .delivery
+        case "storePickup": return .storePickup
+        case "servicePickup": return .servicePickup
+        default: return .shipping
+        }
+    }
+    
+    private static func configureContactRequirements(_ paymentRequest: PKPaymentRequest, request: PaymentRequest) {
+        if request.billingContactRequired == true {
+            paymentRequest.requiredBillingContactFields = [.postalAddress, .name]
+        }
+        
+        if request.shippingContactRequired == true {
+            paymentRequest.requiredShippingContactFields = [.postalAddress, .name]
+        }
+    }
+}
+
+// MARK: - Payment Token Converter
+
+private struct PaymentTokenConverter {
+    
+    static func convert(_ pkToken: PKPaymentToken) -> PaymentToken {
+        let paymentMethod = convertPaymentMethod(pkToken.paymentMethod)
+        
+        return PaymentToken.init(
+            paymentMethod: paymentMethod,
+            transactionIdentifier: pkToken.transactionIdentifier,
+            paymentData: pkToken.paymentData.base64EncodedString()
+        )
+    }
+    
+    private static func convertPaymentMethod(_ pkMethod: PKPaymentMethod) -> PaymentMethod {
+        return PaymentMethod.init(
+            displayName: pkMethod.displayName,
+            network: pkMethod.network.map { PassKitTypeMapper.convert($0) },
+            type: PassKitTypeMapper.convert(pkMethod.type),
+            secureElementPass: convertSecureElementPass(pkMethod),
+            billingAddress: convertBillingAddress(pkMethod)
+        )
+    }
+    
+    private static func convertSecureElementPass(_ pkMethod: PKPaymentMethod) -> PKSecureElementPass? {
+        if #available(iOS 13.4, *) {
+            guard let pkSecureElementPass = pkMethod.secureElementPass else { return nil }
+            return PassKitTypeMapper.convert(pkSecureElementPass)
+        }
+        return nil
+    }
+    
+    private static func convertBillingAddress(_ pkMethod: PKPaymentMethod) -> CNContact? {
+        if #available(iOS 13.0, *) {
+            guard let billingAddress = pkMethod.billingAddress else { return nil }
+            return PassKitTypeMapper.convert(billingAddress)
+        }
+        return nil
+    }
+}
+
+// MARK: - Payment Delegate
+
+private class PaymentDelegate: NSObject, PKPaymentAuthorizationViewControllerDelegate {
+    private weak var paymentHandler: HybridPaymentHandler?
+    private var paymentAuthorized: Bool = false
+    
+    init(paymentHandler: HybridPaymentHandler) {
+        self.paymentHandler = paymentHandler
+    }
+    
+    func paymentAuthorizationViewController(
+        _ controller: PKPaymentAuthorizationViewController,
+        didAuthorizePayment payment: PKPayment,
+        handler completion: @escaping (PKPaymentAuthorizationResult) -> Void
+    ) {
+        paymentAuthorized = true
+        
+        // Simulate payment processing
+        let workItem = DispatchWorkItem {
+            completion(PKPaymentAuthorizationResult(status: .success, errors: nil))
+            
+            let paymentToken = PaymentTokenConverter.convert(payment.token)
+            let transactionId = UUID().uuidString
+            let result = PaymentResult.init(
+                success: true,
+                transactionId: transactionId,
+                token: paymentToken,
+                error: nil
+            )
+            
+            self.paymentHandler?.handlePaymentResult(result)
+        }
+        
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0, execute: workItem)
+    }
+    
+    func paymentAuthorizationViewControllerDidFinish(_ controller: PKPaymentAuthorizationViewController) {
+        controller.dismiss(animated: true) {
+            if !self.paymentAuthorized {
+                let result = PaymentResult.init(
+                    success: false,
+                    transactionId: nil,
+                    token: nil,
+                    error: ErrorMessage.paymentCancelled
+                )
+                self.paymentHandler?.handlePaymentResult(result)
+            }
+        }
+    }
+}
+
+// MARK: - Hybrid Payment Handler
+
+class HybridPaymentHandler: HybridPaymentHandlerSpec {
+    private var currentPaymentRequest: PKPaymentRequest?
+    private var paymentCompletion: ((PaymentResult) -> Void)?
+    private var delegate: PaymentDelegate?
+    
+    // MARK: - Public Methods
+    
+    func payServiceStatus() throws -> PayServiceStatus {
+        let canMakePayments = PKPaymentAuthorizationViewController.canMakePayments()
+        let canSetupCards = PKPaymentAuthorizationViewController.canMakePayments(usingNetworks: [])
+        return PayServiceStatus.init(canMakePayments, canSetupCards)
+    }
+    
+    func canMakePayments(usingNetworks: [String]) throws -> Bool {
+        let networks = usingNetworks.compactMap { PassKitTypeMapper.convertToPKPaymentNetwork($0) }
+        return PKPaymentAuthorizationViewController.canMakePayments(usingNetworks: networks)
+    }
+    
+    func startPayment(request: PaymentRequest) throws -> Promise<PaymentResult> {
+        let promise = Promise<PaymentResult>()
+        
+        DispatchQueue.main.async {
+            self.performPayment(request: request) { result in
+                promise.resolve(withResult: result)
+            }
+        }
+        
+        return promise
+    }
+    
+    // MARK: - Internal Methods
+    
+    func handlePaymentResult(_ result: PaymentResult) {
+        paymentCompletion?(result)
+    }
+    
+    // MARK: - Private Methods
+    
+    private func performPayment(request: PaymentRequest, completion: @escaping (PaymentResult) -> Void) {
+        let paymentRequest = PaymentRequestBuilder.build(from: request)
+        
+        paymentCompletion = completion
+        currentPaymentRequest = paymentRequest
+        delegate = PaymentDelegate(paymentHandler: self)
+        
+        guard let paymentAuthVC = PKPaymentAuthorizationViewController(paymentRequest: paymentRequest) else {
+            completion(createErrorResult(ErrorMessage.unableToCreate))
+            return
+        }
+        
+        paymentAuthVC.delegate = delegate
+        
+        guard let rootViewController = UIApplication.shared.windows.first?.rootViewController else {
+            completion(createErrorResult(ErrorMessage.unableToPresent))
+            return
+        }
+        
+        rootViewController.present(paymentAuthVC, animated: true)
+    }
+    
+    private func createErrorResult(_ error: String) -> PaymentResult {
+        return PaymentResult.init(
+            success: false,
+            transactionId: nil,
+            token: nil,
+            error: error
+        )
+    }
+}

package/ios/PassKitTypeMapper.swift

@@ -0,0 +1,192 @@
+import PassKit
+import Contacts
+import NitroModules
+
+// MARK: - Constants
+
+private enum PaymentNetworkString {
+    static let visa = "visa"
+    static let mastercard = "mastercard"
+    static let amex = "amex"
+    static let discover = "discover"
+    static let jcb = "jcb"
+    static let maestro = "maestro"
+    static let electron = "electron"
+    static let elo = "elo"
+    static let idcredit = "idcredit"
+    static let interac = "interac"
+    static let privateLabel = "privateLabel"
+}
+
+// MARK: - Type Converter
+
+/// Converts Apple PassKit and Contacts types to Nitro-generated types
+enum PassKitTypeMapper {
+    
+    // MARK: - Enum Conversions
+    
+    static func convert(_ network: PKPaymentNetwork) -> PaymentNetwork {
+        switch network {
+        case .visa: return .visa
+        case .masterCard: return .mastercard
+        case .amex: return .amex
+        case .discover: return .discover
+        case .JCB: return .jcb
+        case .maestro: return .maestro
+        case .electron: return .electron
+        case .elo: return .elo
+        case .idCredit: return .idcredit
+        case .interac: return .interac
+        case .privateLabel: return .privatelabel
+        default: return .visa
+        }
+    }
+    
+    static func convert(_ type: PKPaymentMethodType) -> PaymentMethodType {
+        switch type {
+        case .unknown: return .unknown
+        case .debit: return .debit
+        case .credit: return .credit
+        case .prepaid: return .prepaid
+        case .store: return .store
+        default: return .unknown
+        }
+    }
+    
+    
+    static func convertContactType(_ type: Contacts.CNContactType) -> CNContactType {
+        switch type {
+        case .person: return .person
+        case .organization: return .organization
+        @unknown default: return .person
+        }
+    }
+    
+    // MARK: - String to Enum Conversions
+    
+    static func convertToPKPaymentNetwork(_ string: String) -> PKPaymentNetwork? {
+        switch string {
+        case PaymentNetworkString.visa: return .visa
+        case PaymentNetworkString.mastercard: return .masterCard
+        case PaymentNetworkString.amex: return .amex
+        case PaymentNetworkString.discover: return .discover
+        case PaymentNetworkString.jcb: return .JCB
+        case PaymentNetworkString.maestro: return .maestro
+        case PaymentNetworkString.electron: return .electron
+        case PaymentNetworkString.elo: return .elo
+        case PaymentNetworkString.idcredit: return .idCredit
+        case PaymentNetworkString.interac: return .interac
+        case PaymentNetworkString.privateLabel: return .privateLabel
+        default: return nil
+        }
+    }
+    
+    // MARK: - Struct Conversions
+    
+    @available(iOS 13.4, *)
+    static func convert(_ pkPass: PassKit.PKSecureElementPass) -> PKSecureElementPass {
+        // Convert passActivationState using type inference from the property
+        let activationState: PassActivationState
+        switch pkPass.passActivationState {
+        case .activated: activationState = .activated
+        case .requiresActivation: activationState = .requiresactivation
+        case .activating: activationState = .activating
+        case .suspended: activationState = .suspended
+        case .deactivated: activationState = .deactivated
+        @unknown default: activationState = .deactivated
+        }
+        
+        return PKSecureElementPass.init(
+            primaryAccountIdentifier: pkPass.primaryAccountIdentifier,
+            primaryAccountNumberSuffix: pkPass.primaryAccountNumberSuffix,
+            deviceAccountIdentifier: pkPass.deviceAccountIdentifier,
+            deviceAccountNumberSuffix: pkPass.deviceAccountNumberSuffix,
+            passActivationState: activationState,
+            devicePassIdentifier: pkPass.devicePassIdentifier,
+            pairedTerminalIdentifier: pkPass.pairedTerminalIdentifier,
+            passTypeIdentifier: pkPass.passTypeIdentifier,
+            serialNumber: pkPass.serialNumber,
+            organizationName: pkPass.organizationName
+        )
+    }
+    
+    @available(iOS 13.0, *)
+    static func convert(_ contact: Contacts.CNContact) -> CNContact {
+        let contactType = convertContactType(contact.contactType)
+        
+        return CNContact.init(
+            identifier: contact.identifier,
+            contactType: contactType,
+            namePrefix: contact.namePrefix,
+            givenName: contact.givenName,
+            middleName: contact.middleName,
+            familyName: contact.familyName,
+            previousFamilyName: contact.previousFamilyName,
+            nameSuffix: contact.nameSuffix,
+            nickname: contact.nickname,
+            organizationName: contact.organizationName,
+            departmentName: contact.departmentName,
+            jobTitle: contact.jobTitle,
+            phoneticGivenName: contact.phoneticGivenName,
+            phoneticMiddleName: contact.phoneticMiddleName,
+            phoneticFamilyName: contact.phoneticFamilyName,
+            phoneticOrganizationName: contact.phoneticOrganizationName,
+            note: contact.note,
+            imageDataAvailable: contact.imageDataAvailable,
+            phoneNumbers: convertPhoneNumbers(contact.phoneNumbers),
+            emailAddresses: convertEmailAddresses(contact.emailAddresses),
+            postalAddresses: convertPostalAddresses(contact.postalAddresses)
+        )
+    }
+    
+    // MARK: - Private Helpers
+    
+    @available(iOS 13.0, *)
+    private static func convertPhoneNumbers(_ phoneNumbers: [Contacts.CNLabeledValue<Contacts.CNPhoneNumber>]) -> [CNLabeledPhoneNumber] {
+        return phoneNumbers.map { labeledValue in
+            let contactsPhoneNumber = labeledValue.value
+            let nitroPhoneNumber = CNPhoneNumber.init(stringValue: contactsPhoneNumber.stringValue)
+            
+            return CNLabeledPhoneNumber.init(
+                label: labeledValue.label,
+                value: nitroPhoneNumber
+            )
+        }
+    }
+    
+    @available(iOS 13.0, *)
+    private static func convertEmailAddresses(_ emailAddresses: [Contacts.CNLabeledValue<NSString>]) -> [CNLabeledEmailAddress] {
+        return emailAddresses.map { labeledValue in
+            // Extract the NSString value and convert to Swift String
+            let emailString = String(labeledValue.value)
+            let labelString = labeledValue.label
+            
+            // Create Nitro CNLabeledEmailAddress with Swift String values
+            return CNLabeledEmailAddress.init(
+                label: labelString,
+                value: emailString
+            )
+        }
+    }
+    
+    @available(iOS 13.0, *)
+    private static func convertPostalAddresses(_ postalAddresses: [Contacts.CNLabeledValue<Contacts.CNPostalAddress>]) -> [CNLabeledPostalAddress] {
+        return postalAddresses.map { labeledValue in
+            let contactsAddress = labeledValue.value
+            let nitroAddress = CNPostalAddress.init(
+                street: contactsAddress.street,
+                city: contactsAddress.city,
+                state: contactsAddress.state,
+                postalCode: contactsAddress.postalCode,
+                country: contactsAddress.country,
+                isoCountryCode: contactsAddress.isoCountryCode
+            )
+            
+            return CNLabeledPostalAddress.init(
+                label: labeledValue.label,
+                value: nitroAddress
+            )
+        }
+    }
+}
+

package/lib/hooks/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * React hooks for payment operations
+ *
+ * @module hooks
+ */
+export { usePaymentCheckout } from './usePaymentCheckout';
+export type { UsePaymentCheckoutConfig, UsePaymentCheckoutReturn, } from './usePaymentCheckout';

package/lib/hooks/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * React hooks for payment operations
+ *
+ * @module hooks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePaymentCheckout = void 0;
+var usePaymentCheckout_1 = require("./usePaymentCheckout");
+Object.defineProperty(exports, "usePaymentCheckout", { enumerable: true, get: function () { return usePaymentCheckout_1.usePaymentCheckout; } });