react-native-tpay 0.3.0

package/ios/Source/Presentation/AddCardPresentation.swift

@@ -0,0 +1,43 @@
+import React
+import Tpay
+
+final class AddCardPresentation: AddCardDelegate {
+
+    // MARK: - Properties
+
+    var addCardResult: ((String) -> Void)?
+
+    private var addCardSheet: AddCard.Sheet?
+    private let currnetViewController = RCTPresentedViewController()
+
+    // MARK: - API
+
+    func presentAddCard(for payer: Payer) throws {
+        addCardSheet = AddCard.Sheet(payer: payer, delegate: self)
+
+        guard let currnetViewController = currnetViewController else {
+            return
+        }
+
+        try addCardSheet?.present(from: currnetViewController)
+    }
+
+    // MARK: - AddCardDelegate
+
+    func onTokenizationCompleted() {
+        addCardResult?(ConfigurationResult.tokenizationCompleted().toJson())
+        complete()
+    }
+
+    func onTokenizationCancelled() {
+        addCardResult?(ConfigurationResult.tokenizationCancelled().toJson())
+        complete()
+    }
+
+    // MARK: - Private
+
+    private func complete() {
+        addCardSheet?.dismiss()
+        addCardSheet = nil
+    }
+}

package/ios/Source/Presentation/CardTokenPresentation.swift

@@ -0,0 +1,48 @@
+import React
+import Tpay
+
+final class CardTokenPresentation: CardTokenPaymentDelegate {
+
+    // MARK: - Properties
+
+    var cardTokenPaymentResult: ((String) -> Void)?
+
+    private var cardTokenSheet: CardTokenPayment.Sheet?
+    private let currnetViewController = RCTPresentedViewController()
+
+    // MARK: - API
+
+    func presentPayment(for transaction: Transaction) throws {
+        cardTokenSheet = CardTokenPayment.Sheet(transaction: transaction, delegate: self)
+
+        guard let currnetViewController = currnetViewController else {
+            return
+        }
+
+        try cardTokenSheet?.present(from: currnetViewController)
+    }
+
+    // MARK: - CardTokenPaymentDelegate
+
+    func onCardTokenPaymentCompleted(transactionId: TransactionId) {
+        cardTokenPaymentResult?(ConfigurationResult.tokenPaymentCompleted(transactionId: transactionId).toJson())
+        complete()
+    }
+
+    func onCardTokenPaymentCancelled(transactionId: TransactionId) {
+        cardTokenPaymentResult?(ConfigurationResult.tokenPaymentCancelled(transactionId: transactionId).toJson())
+        complete()
+    }
+
+    func onCardTokenErrorOccured(error: ModuleError) {
+        cardTokenPaymentResult?(ConfigurationResult.tokenPayment(error: error).toJson())
+        complete()
+    }
+
+    // MARK: - Private
+
+    private func complete() {
+        cardTokenSheet?.dismiss()
+        cardTokenSheet = nil
+    }
+}

package/ios/Source/Presentation/PaymentPresentation.swift

@@ -0,0 +1,48 @@
+import React
+import Tpay
+
+final class PaymentPresentation: PaymentDelegate {
+
+    // MARK: - Properties
+
+    var paymentResult: ((String) -> Void)?
+
+    private var paymentSheet: Payment.Sheet?
+    private let currnetViewController = RCTPresentedViewController()
+
+    // MARK: - API
+
+    func presentPayment(for transaction: Transaction) throws {
+        paymentSheet = Payment.Sheet(transaction: transaction, delegate: self)
+
+        guard let currnetViewController = currnetViewController else {
+            return
+        }
+
+        try paymentSheet?.present(from: currnetViewController)
+    }
+
+    // MARK: - PaymentDelegate
+
+    func onPaymentCompleted(transactionId: String) {
+        paymentResult?(ConfigurationResult.paymentCompleted(transactionId: transactionId).toJson())
+        complete()
+    }
+
+    func onPaymentCancelled(transactionId: String) {
+        paymentResult?(ConfigurationResult.paymentCancelled(transactionId: transactionId).toJson())
+        complete()
+    }
+
+    func onErrorOccured(error: ModuleError) {
+        paymentResult?(ConfigurationResult.payment(error: error).toJson())
+        complete()
+    }
+
+    // MARK: - Private
+
+    private func complete() {
+        paymentSheet?.dismiss()
+        paymentSheet = nil
+    }
+}

package/ios/Source/Provider/DefaultMerchantDetailsProvider.swift

@@ -0,0 +1,32 @@
+import Tpay
+
+final class DefaultMerchantDetailsProvider: MerchantDetailsProvider {
+
+    // MARK: - Properties
+
+    private let merchantDisplayName: [Language: String]
+    private let merchantHeadquarters: [Language: String]
+    private let regulationsLink: [Language: URL]
+
+    // MARK: - Initializers
+
+    init(merchantDisplayName: [Language: String], merchantHeadquarters: [Language: String], regulationsLink: [Language: URL]) {
+        self.merchantDisplayName = merchantDisplayName
+        self.merchantHeadquarters = merchantHeadquarters
+        self.regulationsLink = regulationsLink
+    }
+
+    // MARK: - API
+
+    func merchantDisplayName(for language: Language) -> String {
+        return merchantDisplayName[language]!
+    }
+
+    func merchantHeadquarters(for language: Language) -> String? {
+        return merchantHeadquarters[language]
+    }
+
+    func regulationsLink(for language: Language) -> URL {
+        return regulationsLink[language]!
+    }
+}

package/ios/Source/Provider/DefaultSSLCertificatesProvider.swift

@@ -0,0 +1,14 @@
+import Tpay
+
+final class DefaultSSLCertificatesProvider: SSLCertificatesProvider {
+
+    // MARK: - Properties
+
+    var apiConfiguration: CertificatePinningConfiguration
+
+    // MARK: - Initializers
+
+    init(apiConfiguration: CertificatePinningConfiguration) {
+        self.apiConfiguration = apiConfiguration
+    }
+}

package/ios/Source/TpaySDK.mm

@@ -0,0 +1,35 @@
+#import <Foundation/Foundation.h>
+#import "React/RCTBridgeModule.h"
+
+@interface RCT_EXTERN_MODULE(TpayRNModule, NSObject)
+    RCT_EXTERN_METHOD(configure: (NSString *)json
+                      resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject)
+    RCT_EXTERN_METHOD(startPayment: (NSString *)json
+                      resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject)
+    RCT_EXTERN_METHOD(startCardTokenPayment: (NSString *)json
+                      resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject)
+    RCT_EXTERN_METHOD(tokenizeCard: (NSString *)json
+                      resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject)
+    RCT_EXTERN_METHOD(screenlessCreditCardPayment: (NSString *)json
+                      resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject)
+    RCT_EXTERN_METHOD(screenlessBLIKPayment: (NSString *)json
+                      resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject)
+    RCT_EXTERN_METHOD(screenlessTransferPayment: (NSString *)json
+                      resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject)
+    RCT_EXTERN_METHOD(screenlessAmbiguousBLIKPayment: (NSString *)json
+                      resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject)
+    RCT_EXTERN_METHOD(paymentWithApplePay: (NSString *)json
+                      resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject)
+    RCT_EXTERN_METHOD(availablePaymentMethods: (NSString *)json
+                      resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject)
+@end

package/ios/Source/TpaySDK.swift

@@ -0,0 +1,324 @@
+import Tpay
+import React
+
+@objc(TpayRNModule)
+final class TpayRNModule: NSObject, RCTBridgeModule {
+    
+    static func moduleName() -> String! {
+        "TpayRNModule"
+    }
+
+    // MARK: - Properties
+
+    private let paymentPresentation = PaymentPresentation()
+    private let tokenCardPresentation = CardTokenPresentation()
+    private let addCardPresentation = AddCardPresentation()
+
+    private var blikPayments: [Headless.Models.BlikPaymentResultWithAmbiguousAliases] = []
+
+    // MARK: - Internal
+
+    @objc static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    // MARK: - API
+
+    @objc func configure(_ json: String, resolve: @escaping RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        guard let configuration = MerchantConfiguration(configuration: json),
+              let merchant = configuration.merchant() else {
+            resolve(ConfigurationResult.configurationFailure().toJson())
+            return
+        }
+
+        let preferredLanguage = configuration.preferredLanguage()
+        let paymentMethods = configuration.paymentMethods()
+        let supportedLanguages = configuration.supportedLanguage()
+        let sslCertificatesProvider = configuration.sslCertificatesProvider()
+        let detailsProvider = configuration.detailsProvider()
+
+        do {
+            try TpayModule.setup(merchant: merchant,
+                                 paymentMethods: paymentMethods,
+                                 preferredLanguage: preferredLanguage,
+                                 supportedLanguages: supportedLanguages,
+                                 sslCertificatesProvider: sslCertificatesProvider,
+                                 detailsProvider: detailsProvider)
+            resolve(ConfigurationResult.configurationValid().toJson())
+        } catch {
+            resolve(ConfigurationResult.configurationFailure(error: error).toJson())
+        }
+    }
+
+    @objc func startPayment(_ json: String, resolve: @escaping RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        guard let singleTransaction = TransactionConfiguration.single(transactionConfiguration: json) else {
+            resolve(ConfigurationResult.configurationFailure().toJson())
+            return
+        }
+
+        paymentPresentation.paymentResult = { result in resolve(result) }
+
+        DispatchQueue.main.async { [weak self] in
+            do {
+                try self?.paymentPresentation.presentPayment(for: singleTransaction)
+            } catch {
+                resolve(ConfigurationResult.configurationFailure(error: error).toJson())
+            }
+        }
+    }
+
+    @objc func startCardTokenPayment(_ json: String, resolve: @escaping RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        guard let singleTransaction = TransactionConfiguration.cardTokenTransaction(transactionConfiguration: json) else {
+            resolve(ConfigurationResult.configurationFailure().toJson())
+            return
+        }
+
+        tokenCardPresentation.cardTokenPaymentResult = { result in resolve(result) }
+
+        DispatchQueue.main.async { [weak self] in
+            do {
+                try self?.tokenCardPresentation.presentPayment(for: singleTransaction)
+            } catch {
+                resolve(ConfigurationResult.configurationFailure(error: error).toJson())
+            }
+        }
+    }
+
+    @objc func tokenizeCard(_ json: String, resolve: @escaping RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        guard let tokenizationData = TransactionConfiguration.addCard(tokenisationConfiguration: json) else {
+            resolve(ConfigurationResult.configurationFailure().toJson())
+            return
+        }
+
+        addCardPresentation.addCardResult = { result in resolve(result) }
+
+        DispatchQueue.main.async { [weak self] in
+            do {
+                try TpayModule.configure(callbacks: CallbacksConfiguration.init(successRedirectUrl: tokenizationData.successRedirectUrl != nil ? URL(string: tokenizationData.successRedirectUrl!) : nil, errorRedirectUrl: tokenizationData.errorRedirectUrl != nil ? URL(string: tokenizationData.errorRedirectUrl!) : nil, notificationsUrl: URL(string: tokenizationData.notificationUrl)))
+                try self?.addCardPresentation.presentAddCard(for: tokenizationData.payer)
+            } catch {
+                resolve(ConfigurationResult.configurationFailure(error: error).toJson())
+            }
+        }
+    }
+
+    @objc func screenlessCreditCardPayment(_ json: String, resolve: @escaping RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        Headless.getAvailablePaymentChannels { [weak self] result in
+            switch result {
+            case let .success(paymentChannels):
+                self?.invokeCardPayment(json, resolve: resolve, paymentChannels: paymentChannels)
+            case let .failure(error):
+                resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+            }
+        }
+    }
+
+    @objc func screenlessBLIKPayment(_ json: String, resolve: @escaping RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        Headless.getAvailablePaymentChannels { [weak self] result in
+            switch result {
+            case let .success(paymentChannels):
+                self?.invokeBlikPayment(json, resolve: resolve, paymentChannels: paymentChannels)
+            case let .failure(error):
+                resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+            }
+        }
+    }
+
+    @objc func screenlessTransferPayment(_ json: String, resolve: @escaping RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        Headless.getAvailablePaymentChannels { [weak self] result in
+            switch result {
+            case let .success(paymentChannels):
+                self?.invokeBankPayment(json, resolve: resolve, paymentChannels: paymentChannels)
+            case let .failure(error):
+                resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+            }
+        }
+    }
+
+    @objc func paymentWithApplePay(_ json: String, resolve: @escaping RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        Headless.getAvailablePaymentChannels { [weak self] result in
+            switch result {
+            case let .success(paymentChannels):
+                self?.invokeDigitalwalletPayment(json, resolve: resolve, paymentChannels: paymentChannels)
+            case let .failure(error):
+                resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+            }
+        }
+    }
+
+    @objc func screenlessAmbiguousBLIKPayment(_ json: String, resolve: @escaping RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        guard let continuePayment = TransactionConfiguration.continuePayment(continuePaymentConfiguration: json),
+              let blikTranscation = blikPayments.first(where: { $0.ongoingTransaction.id == continuePayment.id }),
+              let application = blikTranscation.applications.first(where: { $0.key == continuePayment.ambiguousAlias.code && $0.name == continuePayment.ambiguousAlias.name }) else {
+            resolve(ScreenlessResult.methodCallError().toJson())
+            return
+        }
+
+        do {
+            try Headless.continuePayment(for: blikTranscation.ongoingTransaction,
+                                         with: .init(registeredAlias: .init(value: .uid(continuePayment.alias)),
+                                                     application: application)) { result in
+                switch result {
+                case let .success(transaction):
+                    resolve(ScreenlessResult.paymentCreated(continueUrl: transaction.continueUrl, transactionId: transaction.ongoingTransaction.id).toJson())
+                case let .failure(error):
+                    resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+                }
+            }
+        } catch {
+            resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+        }
+    }
+
+    @objc func availablePaymentMethods(resolve: @escaping RCTPromiseResolveBlock, reject _: RCTPromiseRejectBlock) {
+        Headless.getAvailablePaymentChannels { result in
+            switch result {
+            case let .success(paymentMethods):
+                let channels = PaymentMethodsConfiguration.configuration(for: paymentMethods)
+                resolve(PaymentChannelResult.configurationValid(channels: channels).toJson())
+            case let .failure(error):
+                resolve(PaymentChannelResult.configurationError(error: error).toJson())
+            }
+        }
+    }
+
+    // MARK: - Private
+
+    private func invokeCardPayment(_ json: String, resolve: @escaping RCTPromiseResolveBlock, paymentChannels: [Headless.Models.PaymentChannel]) {
+        do {
+            guard let cardPayment = TransactionConfiguration.cardPayment(cardPaymentConfiguration: json, paymentChannels: paymentChannels) else {
+                resolve(ScreenlessResult.methodCallError().toJson())
+                return
+            }
+            try TpayModule.configure(callbacks: cardPayment.callbacks)
+            if let _ = cardPayment.card {
+                try invokeCardDataPayment(cardPayment: cardPayment, resolve: resolve)
+            } else if let _ = cardPayment.cardToken {
+                try invokeCardTokenPayment(cardPayment: cardPayment, resolve: resolve)
+            } else {
+                resolve(ScreenlessResult.methodCallError().toJson())
+            }
+        } catch {
+            resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+        }
+    }
+
+    private func invokeCardDataPayment(cardPayment: CardPayment, resolve: @escaping RCTPromiseResolveBlock) throws {
+        try Headless.invokePayment(for: cardPayment, using: cardPayment.paymentChannel, with: cardPayment.card!) { result in
+            switch result {
+            case let .success(transaction):
+                resolve(ScreenlessResult.paymentCreated(continueUrl: transaction.continueUrl, transactionId: transaction.ongoingTransaction.id).toJson())
+            case let .failure(error):
+                resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+            }
+        }
+    }
+
+    private func invokeCardTokenPayment(cardPayment: CardPayment, resolve: @escaping RCTPromiseResolveBlock) throws {
+        try Headless.invokePayment(for: cardPayment, using: cardPayment.paymentChannel, with: cardPayment.cardToken!) { result in
+            switch result {
+            case let .success(transaction):
+                resolve(ScreenlessResult.paymentCreated(continueUrl: transaction.continueUrl, transactionId: transaction.ongoingTransaction.id).toJson())
+            case let .failure(error):
+                resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+            }
+        }
+    }
+
+    private func invokeBlikPayment(_ json: String, resolve: @escaping RCTPromiseResolveBlock, paymentChannels: [Headless.Models.PaymentChannel]) {
+        guard let blikPayment = TransactionConfiguration.blikPayment(blikPaymentConfiguration: json, paymentChannels: paymentChannels) else {
+            resolve(ScreenlessResult.methodCallError().toJson())
+            return
+        }
+
+        do {
+            try TpayModule.configure(callbacks: blikPayment.callbacks)
+            if let _ = blikPayment.token {
+                try invokeBlikTokenPayment(blikPayment: blikPayment, resolve: resolve)
+            } else if let _ = blikPayment.alias {
+                try invokeBlikAliasPayment(blikPayment: blikPayment, resolve: resolve)
+            } else {
+                resolve(ScreenlessResult.methodCallError().toJson())
+            }
+        } catch {
+            resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+        }
+    }
+
+    private func invokeBlikTokenPayment(blikPayment: BlikPayment, resolve: @escaping RCTPromiseResolveBlock) throws {
+        try Headless.invokePayment(for: blikPayment,
+                                   using: blikPayment.paymentChannel,
+                                   with: Headless.Models.Blik.Regular(token: blikPayment.token!,
+                                                                      aliasToBeRegistered: blikPayment.alias.flatMap { BlikAlias(value: .uid($0)) })) { result in
+            switch result {
+            case let .success(transaction):
+                resolve(ScreenlessResult.paymentCreated(continueUrl: transaction.continueUrl, transactionId: transaction.ongoingTransaction.id).toJson())
+            case let .failure(error):
+                resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+            }
+        }
+    }
+
+    private func invokeBlikAliasPayment(blikPayment: BlikPayment, resolve: @escaping RCTPromiseResolveBlock) throws {
+        try Headless.invokePayment(for: blikPayment,
+                                   using: blikPayment.paymentChannel,
+                                   with: Headless.Models.Blik.OneClick(registeredAlias: .init(value: .uid(blikPayment.alias!)))) { [weak self] result in
+            switch result {
+            case let .success(transaction):
+                if let blikTransaction = transaction as? Headless.Models.BlikPaymentResultWithAmbiguousAliases {
+                    self?.blikPayments.append(blikTransaction)
+                    let aliases = TransactionConfiguration.makeAliases(from: blikTransaction.applications)
+                    resolve(ScreenlessResult.ambiguousAlias(aliases: aliases, transactionId: transaction.ongoingTransaction.id).toJson())
+                } else {
+                    resolve(ScreenlessResult.paymentCreated(continueUrl: transaction.continueUrl, transactionId: transaction.ongoingTransaction.id).toJson())
+                }
+            case let .failure(error):
+                resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+            }
+        }
+    }
+
+    private func invokeBankPayment(_ json: String, resolve: @escaping RCTPromiseResolveBlock, paymentChannels: [Headless.Models.PaymentChannel]) {
+        guard let bankPayment = TransactionConfiguration.bankPayment(bankPaymentConfiguration: json, paymentChannels: paymentChannels) else {
+            resolve(ScreenlessResult.methodCallError().toJson())
+            return
+        }
+
+        do {
+            try TpayModule.configure(callbacks: bankPayment.callbacks)
+            try Headless.invokePayment(for: bankPayment, using: bankPayment.paymentChannel) { result in
+                switch result {
+                case let .success(transaction):
+                    resolve(ScreenlessResult.paymentCreated(continueUrl: transaction.continueUrl, transactionId: transaction.ongoingTransaction.id).toJson())
+                case let .failure(error):
+                    resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+                }
+            }
+        } catch {
+            resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+        }
+    }
+
+    private func invokeDigitalwalletPayment(_ json: String, resolve: @escaping RCTPromiseResolveBlock, paymentChannels: [Headless.Models.PaymentChannel]) {
+        guard let digitalWalletPayment = TransactionConfiguration.digitalWalletPayment(digitalWalletPaymentConfiguration: json,
+                                                                                       paymentChannels: paymentChannels) else {
+            resolve(ScreenlessResult.methodCallError().toJson())
+            return
+        }
+        do {
+            try TpayModule.configure(callbacks: digitalWalletPayment.callbacks)
+            try Headless.invokePayment(for: digitalWalletPayment,
+                                       using: digitalWalletPayment.paymentChannel,
+                                       with: .init(token: digitalWalletPayment.token)) { result in
+                switch result {
+                case let .success(transaction):
+                    resolve(ScreenlessResult.paymentCreated(continueUrl: transaction.continueUrl, transactionId: transaction.ongoingTransaction.id).toJson())
+                case let .failure(error):
+                    resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+                }
+            }
+        } catch {
+            resolve(ScreenlessResult.paymentFailure(error: error).toJson())
+        }
+    }
+}

package/ios/Tpay-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/lib/commonjs/component/tpay_button.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TpayButton = void 0;
+var _reactNative = require("react-native");
+var _react = require("react");
+const TpayButton = ({
+  onClick,
+  isEnabled
+}) => {
+  const [isPressed, setIsPressed] = (0, _react.useState)(false);
+  return /*#__PURE__*/React.createElement(_reactNative.Pressable, {
+    style: {
+      backgroundColor: isPressed ? '#112458' : '#2248B0',
+      borderRadius: 48
+    },
+    onPressIn: _ => setIsPressed(true),
+    onPressOut: _ => {
+      setIsPressed(false);
+      onClick();
+    },
+    disabled: !isEnabled
+  }, /*#__PURE__*/React.createElement(_reactNative.View, {
+    style: styles.tpayLogo
+  }, /*#__PURE__*/React.createElement(_reactNative.Image, {
+    source: require('../assets/tpay_logo.png')
+  })));
+};
+exports.TpayButton = TpayButton;
+const styles = _reactNative.StyleSheet.create({
+  tpayLogo: {
+    alignSelf: 'center',
+    padding: 14
+  }
+});
+//# sourceMappingURL=tpay_button.js.map

package/lib/commonjs/component/tpay_button.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_react","TpayButton","onClick","isEnabled","isPressed","setIsPressed","useState","React","createElement","Pressable","style","backgroundColor","borderRadius","onPressIn","_","onPressOut","disabled","View","styles","tpayLogo","Image","source","exports","StyleSheet","create","alignSelf","padding"],"sourceRoot":"../../../src","sources":["component/tpay_button.tsx"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAcO,MAAME,UAAU,GAAGA,CAAC;EAAEC,OAAO;EAAEC;AAA2B,CAAC,KAAK;EACrE,MAAM,CAACC,SAAS,EAAEC,YAAY,CAAC,GAAG,IAAAC,eAAQ,EAAC,KAAK,CAAC;EAEjD,oBACEC,KAAA,CAAAC,aAAA,CAACV,YAAA,CAAAW,SAAS;IACRC,KAAK,EAAE;MACLC,eAAe,EAAEP,SAAS,GAAG,SAAS,GAAG,SAAS;MAClDQ,YAAY,EAAE;IAChB,CAAE;IACFC,SAAS,EAAGC,CAAC,IAAKT,YAAY,CAAC,IAAI,CAAE;IACrCU,UAAU,EAAGD,CAAC,IAAK;MACjBT,YAAY,CAAC,KAAK,CAAC;MACnBH,OAAO,CAAC,CAAC;IACX,CAAE;IACFc,QAAQ,EAAE,CAACb;EAAU,gBAErBI,KAAA,CAAAC,aAAA,CAACV,YAAA,CAAAmB,IAAI;IAACP,KAAK,EAAEQ,MAAM,CAACC;EAAS,gBAC3BZ,KAAA,CAAAC,aAAA,CAACV,YAAA,CAAAsB,KAAK;IAACC,MAAM,EAAEtB,OAAO,CAAC,yBAAyB;EAAE,CAAE,CAChD,CACG,CAAC;AAEhB,CAAC;AAACuB,OAAA,CAAArB,UAAA,GAAAA,UAAA;AAEF,MAAMiB,MAAM,GAAGK,uBAAU,CAACC,MAAM,CAAC;EAC/BL,QAAQ,EAAE;IACRM,SAAS,EAAE,QAAQ;IACnBC,OAAO,EAAE;EACX;AACF,CAAC,CAAC"}