@gmisoftware/react-native-pay 0.0.4

package/NitroPay.podspec

@@ -0,0 +1,31 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroPay"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported, :visionos => 1.0 }
+  s.source       = { :git => "https://github.com/mrousavy/nitro.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  load 'nitrogen/generated/ios/NitroPay+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,455 @@
+# react-native-pay
+
+A unified React Native payment module supporting both Apple Pay (iOS) and Google Pay (Android) with a consistent API across platforms.
+
+Built with [Nitro Modules](https://nitro.margelo.com/) for high-performance native integration.
+
+## Features
+
+- ✅ **Unified API** - Same interface for both Apple Pay and Google Pay
+- ✅ **One Hook Does Everything** - Simple `usePaymentCheckout()` hook for complete payment flow
+- ✅ **Native UI Components** - Platform-specific payment buttons
+- ✅ **Type-Safe** - Full TypeScript support with comprehensive type definitions
+- ✅ **Configurable** - Dynamic environment and gateway configuration
+- ✅ **Built-in Cart** - Shopping cart functionality included
+- ✅ **Modern Architecture** - Built with Nitro Modules for optimal performance
+- ✅ **Expo Compatible** - Config plugins for easy integration with Expo
+
+## Installation
+
+```bash
+npm install react-native-pay
+# or
+yarn add react-native-pay
+# or
+bun add react-native-pay
+```
+
+### iOS Setup
+
+Add Apple Pay capability to your app and configure merchant identifiers in your Expo config:
+
+```js
+// app.json or app.config.js
+{
+  "plugins": [
+    [
+      "react-native-pay",
+      {
+        "merchantIdentifier": "merchant.com.yourcompany.app"
+      }
+    ]
+  ]
+}
+```
+
+### Android Setup
+
+Enable Google Pay in your Expo config:
+
+```js
+// app.json or app.config.js
+{
+  "plugins": [
+    [
+      "react-native-pay",
+      {
+        "enableGooglePay": true
+      }
+    ]
+  ]
+}
+```
+
+## Usage
+
+### Using the Hook (Recommended)
+
+One hook does everything - availability checking, cart management, and payment processing:
+
+```typescript
+import {
+  usePaymentCheckout,
+  ApplePayButton,
+  GooglePayButton,
+} from 'react-native-pay'
+import { Platform, View, Text, Button, ActivityIndicator } from 'react-native'
+
+function CheckoutScreen() {
+  const {
+    // Payment availability
+    canMakePayments,
+
+    // Cart management
+    items,
+    total,
+    addItem,
+    addItems,
+    removeItem,
+
+    // Payment processing
+    startPayment,
+    isProcessing,
+    error,
+  } = usePaymentCheckout({
+    merchantIdentifier: 'merchant.com.yourcompany.app',
+    currencyCode: 'USD',
+    countryCode: 'US',
+  })
+
+  // Add single item
+  const handleAddCoffee = () => addItem('Coffee', 4.99)
+
+  // Add multiple items at once
+  const handleAddFullOrder = () => addItems([
+    { label: 'Coffee', amount: 4.99 },
+    { label: 'Sandwich', amount: 8.99 },
+    { label: 'Tax', amount: 1.20 }
+  ])
+
+  const handlePay = async () => {
+    const result = await startPayment()
+    if (result?.success) {
+      // Send result.token to your server
+      console.log('Payment successful:', result.transactionId)
+    }
+  }
+
+  if (!canMakePayments) {
+    return <Text>Payment not available</Text>
+  }
+
+  return (
+    <View>
+      <Button title="Add Coffee $4.99" onPress={handleAddCoffee} />
+      <Button title="Add Full Order" onPress={handleAddFullOrder} />
+
+      {items.map((item, i) => (
+        <View key={i}>
+          <Text>{item.label}: ${item.amount}</Text>
+          <Button title="Remove" onPress={() => removeItem(i)} />
+        </View>
+      ))}
+
+      <Text>Total: ${total.toFixed(2)}</Text>
+
+      {error && <Text style={{ color: 'red' }}>{error.message}</Text>}
+
+      {isProcessing ? (
+        <ActivityIndicator />
+      ) : (
+        Platform.OS === 'ios' ? (
+          <ApplePayButton onPress={handlePay} buttonType="buy" buttonStyle="black" />
+        ) : (
+          <GooglePayButton onPress={handlePay} buttonType="buy" theme="dark" />
+        )
+      )}
+    </View>
+  )
+}
+```
+
+### Basic Payment Flow (Without Hooks)
+
+```typescript
+import {
+  HybridPaymentHandler,
+  ApplePayButton,
+  GooglePayButton,
+  createPaymentRequest,
+} from 'react-native-pay'
+import { Platform } from 'react-native'
+
+// Check if payment service is available
+const status = HybridPaymentHandler.payServiceStatus()
+console.log('Can make payments:', status.canMakePayments)
+
+// Create a payment request
+const paymentRequest = createPaymentRequest({
+  merchantIdentifier: 'merchant.com.yourcompany.app',
+  amount: 29.99,
+  label: 'Coffee Subscription',
+  countryCode: 'US',
+  currencyCode: 'USD',
+  // Google Pay specific (optional)
+  googlePayEnvironment: 'TEST', // or 'PRODUCTION'
+  googlePayGateway: 'stripe',
+  googlePayGatewayMerchantId: 'your_gateway_merchant_id',
+})
+
+// Handle payment
+const handlePayment = async () => {
+  try {
+    const result = await HybridPaymentHandler.startPayment(paymentRequest)
+
+    if (result.success) {
+      console.log('Payment successful:', result.transactionId)
+      console.log('Payment token:', result.token)
+      // Send token to your server for processing
+    } else {
+      console.error('Payment failed:', result.error)
+    }
+  } catch (error) {
+    console.error('Payment error:', error)
+  }
+}
+
+// Render platform-specific button
+{Platform.OS === 'ios' ? (
+  <ApplePayButton
+    buttonType="buy"
+    buttonStyle="black"
+    onPress={handlePayment}
+    style={{ width: '100%', height: 48 }}
+  />
+) : (
+  <GooglePayButton
+    buttonType="buy"
+    theme="dark"
+    radius={4}
+    onPress={handlePayment}
+    style={{ width: '100%', height: 48 }}
+  />
+)}
+```
+
+### Payment Request Configuration
+
+```typescript
+interface PaymentRequest {
+  merchantIdentifier: string
+  countryCode: string
+  currencyCode: string
+  paymentItems: PaymentItem[]
+  merchantCapabilities: string[]
+  supportedNetworks: string[]
+  shippingType?: string
+  shippingMethods?: PaymentItem[]
+  billingContactRequired?: boolean
+  shippingContactRequired?: boolean
+  // Google Pay specific (Android only)
+  googlePayEnvironment?: 'TEST' | 'PRODUCTION'
+  googlePayGateway?: string
+  googlePayGatewayMerchantId?: string
+}
+```
+
+### Utility Helpers
+
+The package includes helpful utilities for common operations:
+
+```typescript
+import {
+  createPaymentItem,
+  calculateTotal,
+  formatNetworkName,
+} from 'react-native-pay'
+
+// Create payment items
+const item1 = createPaymentItem('Subscription', 29.99, 'final')
+const item2 = createPaymentItem('Tax', 2.4, 'final')
+
+// Calculate total
+const total = calculateTotal([item1, item2]) // 32.39
+
+// Format network names
+formatNetworkName('visa') // "Visa"
+formatNetworkName('amex') // "American Express"
+```
+
+## API Reference
+
+### React Hook
+
+#### `usePaymentCheckout(config)`
+
+All-in-one hook for payment checkout flow.
+
+**Configuration:**
+
+```typescript
+{
+  merchantIdentifier: string
+  countryCode?: string              // Default: 'US'
+  currencyCode?: string              // Default: 'USD'
+  supportedNetworks?: string[]       // Default: ['visa', 'mastercard', 'amex', 'discover']
+  merchantCapabilities?: string[]    // Default: ['3DS']
+  googlePayEnvironment?: 'TEST' | 'PRODUCTION'
+  googlePayGateway?: string
+  googlePayGatewayMerchantId?: string
+}
+```
+
+**Returns:**
+
+```typescript
+{
+  // Payment availability
+  canMakePayments: boolean
+  canSetupCards: boolean
+  isCheckingStatus: boolean
+
+  // Cart management
+  items: PaymentItem[]
+  total: number
+  addItem: (label: string, amount: number, type?: 'final' | 'pending') => void
+  addItems: (items: Array<{ label, amount, type? }>) => void  // Add multiple at once
+  removeItem: (index: number) => void
+  updateItem: (index: number, updates: Partial<PaymentItem>) => void
+  clearItems: () => void
+
+  // Payment processing
+  startPayment: () => Promise<PaymentResult | null>
+  isProcessing: boolean
+  result: PaymentResult | null
+  error: Error | null
+
+  // Utilities
+  reset: () => void
+  paymentRequest: PaymentRequest  // Full request object
+}
+```
+
+**Example:**
+
+```typescript
+const checkout = usePaymentCheckout({
+  merchantIdentifier: 'merchant.com.example',
+  currencyCode: 'USD',
+  countryCode: 'US',
+})
+
+// Add single item
+checkout.addItem('Product', 29.99)
+
+// Add multiple items at once
+checkout.addItems([
+  { label: 'Product', amount: 29.99 },
+  { label: 'Shipping', amount: 5.0 },
+  { label: 'Tax', amount: 2.8, type: 'final' },
+])
+
+// Check total
+console.log(checkout.total) // 37.79
+
+// Process payment
+const result = await checkout.startPayment()
+if (result?.success) {
+  // Handle success
+}
+```
+
+### HybridPaymentHandler
+
+#### `payServiceStatus(): PayServiceStatus`
+
+Returns the current payment service availability.
+
+```typescript
+const status = HybridPaymentHandler.payServiceStatus()
+console.log(status.canMakePayments) // boolean
+console.log(status.canSetupCards) // boolean
+```
+
+#### `startPayment(request: PaymentRequest): Promise<PaymentResult>`
+
+Initiates a payment request.
+
+```typescript
+const result = await HybridPaymentHandler.startPayment(paymentRequest)
+```
+
+#### `canMakePayments(usingNetworks: string[]): boolean`
+
+Checks if the device can make payments using specific networks.
+
+```typescript
+const canPay = HybridPaymentHandler.canMakePayments(['visa', 'mastercard'])
+```
+
+### Button Components
+
+#### ApplePayButton (iOS)
+
+```typescript
+<ApplePayButton
+  buttonType="buy" | "setup" | "book" | "donate" | "order" | "continue" | ...
+  buttonStyle="white" | "black" | "whiteOutline" | "automatic"
+  onPress={() => handlePayment()}
+  style={styles.button}
+/>
+```
+
+#### GooglePayButton (Android)
+
+```typescript
+<GooglePayButton
+  buttonType="buy" | "book" | "checkout" | "donate" | "order" | "pay" | "subscribe" | "plain"
+  theme="dark" | "light"
+  radius={4} // optional corner radius
+  onPress={() => handlePayment()}
+  style={styles.button}
+/>
+```
+
+## Architecture
+
+### Package Structure
+
+```
+package/
+├── android/                          # Android implementation
+│   └── src/main/java/com/.../pay/
+│       ├── Constants.kt              # Shared constants
+│       ├── GooglePayButtonFactory.kt # Button creation utility
+│       ├── GooglePayRequestBuilder.kt # Payment request builder
+│       ├── HybridGooglePayButton.kt  # Button component
+│       ├── HybridPaymentHandler.kt   # Payment handler
+│       ├── NitroPayPackage.kt        # RN package
+│       └── PaymentMapper.kt          # Data mapper
+├── ios/                              # iOS implementation
+│   ├── ApplePayButtonFactory.swift   # Button creation utility
+│   ├── HybridApplePayButton.swift    # Button component
+│   ├── HybridPaymentHandler.swift    # Payment handler
+│   └── PassKitTypeMapper.swift       # Type converter
+├── src/                              # TypeScript/JavaScript
+│   ├── specs/                        # Nitro type specs
+│   │   ├── ApplePayButton.nitro.ts
+│   │   ├── GooglePayButton.nitro.ts
+│   │   └── PaymentHandler.nitro.ts
+│   ├── types/                        # Type definitions
+│   │   ├── Contact.ts
+│   │   └── Payment.ts
+│   ├── utils/                        # Utility helpers
+│   │   └── paymentHelpers.ts
+│   ├── plugin/                       # Expo config plugins
+│   │   ├── withApplePay.ts
+│   │   └── withGooglePay.ts
+│   └── index.ts                      # Public API
+└── nitrogen/                         # Generated code (auto-generated)
+```
+
+### Design Principles
+
+1. **Separation of Concerns**: Each component has a single, well-defined responsibility
+2. **Factory Pattern**: Button and request creation abstracted into factory classes
+3. **Type Safety**: Comprehensive TypeScript definitions with runtime validation
+4. **Code Reusability**: Shared utilities and helpers reduce duplication
+5. **Platform Consistency**: Unified API abstracts platform differences
+
+## Contributing
+
+Contributions are welcome! Please ensure:
+
+- Code follows existing patterns and style
+- All TypeScript types are properly defined
+- Native code is properly documented
+- Tests pass (when available)
+
+## License
+
+MIT
+
+## Credits
+
+Built with [Nitro Modules](https://nitro.margelo.com/) by [Margelo](https://margelo.com/)

package/android/CMakeLists.txt

@@ -0,0 +1,29 @@
+project(NitroPay)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME NitroPay)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED
+        src/main/cpp/cpp-adapter.cpp
+)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroPay+autolinking.cmake)
+
+# Set up local includes
+include_directories(
+        "src/main/cpp"
+        "../cpp"
+)
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android                                   # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,144 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.13.0"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/NitroPay+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroPay_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroPay_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.pay"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+  
+  // Google Pay dependencies
+  implementation 'com.google.android.gms:play-services-wallet:19.3.0'
+}
+

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}