judokit-react-native 4.1.2 → 4.2.0

package/JudoKit-ReactNative.podspec

@@ -0,0 +1,42 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+Pod::Spec.new do |s|
+  s.name         = "JudoKit-ReactNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "12.0" }
+  s.source       = { :git => "https://github.com/Judopay/JudoKit-ReactNative.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+  s.dependency "JudoKit-iOS", "3.3.1"
+
+  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
+  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+  s.dependency "React-Core"
+
+  # Don't install the dependencies when we run `pod install` in the old architecture.
+  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+    s.pod_target_xcconfig    = {
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+    }
+    s.dependency "React-Codegen"
+    s.dependency "RCT-Folly"
+    s.dependency "RCTRequired"
+    s.dependency "RCTTypeSafety"
+    s.dependency "ReactCommon/turbomodule/core"
+   end
+  end
+end

package/LICENSE

@@ -1,7 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Judopay
-
+Copyright (c) 2019-2024 Alternative Payments Ltd
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights

package/README.md

@@ -1,136 +1,123 @@
-# JudoPay React Native module
+# JudoKit-ReactNative
 
-JudoPay's React Native module and sample app. This module is a wrapper around the JudoKit-iOS library on iOS and the JudoKit-Android library on Android.
+[![npm version](https://badge.fury.io/js/judokit-react-native.svg)](https://www.npmjs.com/package/judokit-react-native)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![React Native](https://img.shields.io/badge/React%20Native-%3E%3D0.70-blue.svg)](https://facebook.github.io/react-native/)
+[![install size](https://packagephobia.com/badge?p=judokit-react-native)](https://packagephobia.com/result?p=judokit-react-native)
+[![CircleCI](https://dl.circleci.com/status-badge/img/gh/Judopay/JudoKit-ReactNative/tree/master.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/Judopay/JudoKit-ReactNative/tree/master)
 
-## Features
+[![NPM](https://nodei.co/npm/judokit-react-native.png?downloads=true&mini=true)](https://nodei.co/npm/judokit-react-native/)
 
-- Card transactions *(Payment, PreAuth, Save Card, Register Card, Check Card)*;
-- Token payments/pre-auths;
-- Apple Pay;
-- Google Pay;
-- iDEAL;
-- Pay By Bank App;
-- 3DS;
-- Server-to-server transactions;
-- Payment Method Selection screen;
+A React Native module for the Judopay native [JudoKit-iOS](https://github.com/Judopay/JudoKit-iOS) and [JudoKit-Android](https://github.com/Judopay/JudoKit-Android) to process payments on iOS and Android.
 
-## Getting started
+## Installation
 
--   `yarn add judokit-react-native`
-
-    or if you use npm: `npm install judokit-react-native --save`
-
-### iOS
-
--   Make sure that the minimum deployment target is set to `11.0` or higher in your `ios/Podfile` :
-
-    `platform :ios, '11.0'`
-
--   Install Cocopods
-
-    `cd ios && pod install`
-
-### Android
-
--   Make sure that `minSdkVersion` is set to 19 or higher in your `android/build.gradle`:
-
-    ```
-    buildscript {
-        ext {
-            buildToolsVersion = "29.0.3"
-            minSdkVersion = 19
-            compileSdkVersion = 29
-            targetSdkVersion = 29
-        }
-        ...
-    }
-    ```
-
--   Make sure that you use Android Gradle plugin version 4.0.1+ in your `android/build.gradle`:
-
-    ```
-    dependencies {
-        classpath 'com.android.tools.build:gradle:4.0.1'
-    }
-    ```
-
--   Add the Judopay maven repository to `allprojects / repositories` in your `android/build.gradle`:
-
-    ```
-    allprojects {
-        repositories {
-            mavenLocal()
-
-            mavenCentral()
-            google()
-            maven {
-                // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
-                url("$rootDir/../node_modules/react-native/android")
-            }
-            maven {
-                // Android JSC is installed from npm
-                url("$rootDir/../node_modules/jsc-android/dist")
-            }
-        }
-    }
-
-    ```
-
-## Update an existing project
-
-`yarn upgrade judokit-react-native`
-
-### iOS
-
--   Update Cocoapods
-
-    `cd ios && pod update JudoKit-iOS`
-
-### Android
-
-- Rebuild your project
+```sh
+yarn add judokit-react-native
+```
 
 ## Usage
-
-For a detailed description of all features, visit [our documentation](https://docs.judopay.com/) or try out the sample app attached to the package.
-
 ```ts
+import JudoPay, {JudoTransactionType} from 'judokit-react-native';
+
+const judoKit = new JudoPay({
+  token: 'your-judo-token',
+  paymentSession: 'your-payment-session',
+});
+
+judoKit
+  .invokeTransaction(JudoTransactionType.Payment, {
+    judoId: '123456',
+    amount: {
+      value: '1.5',
+      currency: 'GBP',
+    },
+    reference: {
+      paymentReference: 'your-payment-reference',
+      consumerReference: 'your-consumer-reference',
+    },
+  })
+  .then(
+    response => {
+      console.log(response);
+    },
+    error => {
+      console.error(error);
+    },
+  );
 
-import Judo, {
+```
+## Example
+Below is a simple example to showcase the basic usage of the library.
+```tsx
+import JudoPay, {
+  JudoAmount,
   JudoAuthorization,
+  JudoConfiguration,
+  JudoReference,
   JudoTransactionType,
-} from 'judokit-react-native'
+} from 'judokit-react-native';
+import React from 'react';
+import {Button, StyleSheet, View} from 'react-native';
+
+const authorization: JudoAuthorization = {
+  token: 'your-judo-token',
+  paymentSession: 'your-payment-session',
+};
+
+const judoKit = new JudoPay(authorization);
+
+function App(): React.JSX.Element {
+  const invokeJudoKit = () => {
+    const amount: JudoAmount = {value: '1.5', currency: 'GBP'};
+    const reference: JudoReference = {
+      paymentReference: 'your-payment-reference',
+      consumerReference: 'your-consumer-reference',
+    };
+
+    const configuration: JudoConfiguration = {
+      amount,
+      judoId: '123456',
+      reference,
+    };
+
+    judoKit.invokeTransaction(JudoTransactionType.Payment, configuration).then(
+      response => {
+        console.log(response);
+      },
+      error => {
+        console.error(error);
+      },
+    );
+  };
+
+  return (
+    <View style={styles.container}>
+      <Button title="Invoke JudoKit" onPress={invokeJudoKit} />
+    </View>
+  );
+}
 
-// 1. Create a Judo session by providing an authorization object (basic or session)
-const auth: JudoAuthorization = {token: 'YOUR-TOKEN', secret: 'YOUR_SECRET'}
-const judo = new Judo(auth)
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+});
 
-// 2. Set the Judo session to sandbox mode for testing
-judo.isSandboxed = true
+export default App;
 
-// 3. Create a Judo configuration to setup your payment flow
-const amount: JudoAmount = {
-    value: '0.01',
-    currency: 'GBP',
-}
+```
 
-const reference: JudoReference = {
-    consumerReference: 'MY-CONSUMER-REFERENCE',
-    paymentReference: 'MY-PAYMENT-REFERENCE'
-}
+## Contributing
+If you want to contribute to this project, follow instructions from [CONTRIBUTING](https://github.com/Judopay/JudoKit-ReactNative/blob/master/CONTRIBUTING.md) file.
 
-const configuration: JudoConfiguration = {
-    judoId: 'MY-JUDO-ID',
-    amount: amount,
-    reference: reference
-}
+## See also
 
-// 4. Invoke a payment transaction and handle the result
-judo.invokeTransaction(JudoTransactionType.Payment, configuration)
-    .then((response) => {
-        // Handle response
-    })
-    .catch((error) => {
-       // Handle error
-    });
-```
+- [JudoKit-ReactNative documentation](https://docs.judopay.com/Content/Mobile/React_Native.htm)
+- [Judopay Transaction API documentation](https://docs.judopay.com/api-reference/index.html)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/Judopay/JudoKit-ReactNative/blob/master/LICENSE) file for details.

package/android/build.gradle

@@ -1,233 +1,96 @@
-apply plugin: 'com.android.library'
-apply plugin: 'kotlin-android'
-apply plugin: 'de.mannodermaus.android-junit5'
-apply plugin: 'jacoco'
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["JudoKitReactNative_kotlinVersion"]
 
-def DEFAULT_COMPILE_SDK_VERSION = 33
-def DEFAULT_MIN_SDK_VERSION = 21
-def DEFAULT_TARGET_SDK_VERSION = 33
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
 
 def isNewArchitectureEnabled() {
-    return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
 
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
 if (isNewArchitectureEnabled()) {
-    apply plugin: 'com.facebook.react'
+  apply plugin: "com.facebook.react"
 }
 
-def getExtOrIntegerDefault(name, fallback) {
-    return rootProject.ext.has(name) ? rootProject.ext.get(name) : (fallback).toInteger()
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["JudoKitReactNative_" + name]
 }
 
-buildscript {
-    ext.kotlin_version = '1.7.20'
-    ext.junit5_version = '5.9.1'
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["JudoKitReactNative_" + name]).toInteger()
+}
 
-    repositories {
-        maven { url 'https://plugins.gradle.org/m2/' }
-        google()
-        mavenCentral()
-    }
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
 
-    dependencies {
-        classpath 'com.android.tools.build:gradle:7.3.1'
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath 'de.mannodermaus.gradle.plugins:android-junit5:1.8.2.1'
-    }
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
 }
 
 android {
-    compileSdkVersion getExtOrIntegerDefault('compileSdkVersion', DEFAULT_COMPILE_SDK_VERSION)
+  if (supportsNamespace()) {
+    namespace "com.judopay.judokit.reactnative"
 
-    defaultConfig {
-        minSdkVersion getExtOrIntegerDefault('minSdkVersion', DEFAULT_MIN_SDK_VERSION)
-        targetSdkVersion getExtOrIntegerDefault('targetSdkVersion', DEFAULT_TARGET_SDK_VERSION)
-        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
-    }
-    buildTypes {
-        release {
-            minifyEnabled false
-        }
-        debug {
-            testCoverageEnabled true
-        }
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
     }
+  }
 
-    lintOptions {
-        disable 'GradleCompatible'
-    }
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
-    testOptions {
-        animationsDisabled = true
-        unitTests.returnDefaultValues = true
-        unitTests.all {
-            jacoco {
-                includeNoLocationClasses = true
-                jacoco.excludes = ['jdk.internal.*']
-            }
-        }
-    }
-}
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
 
-repositories {
-    mavenLocal()
-    mavenCentral()
-    google()
+  }
 
-    def found = false
-    def defaultDir = null
-    def androidSourcesName = 'React Native sources'
-
-    if (rootProject.ext.has('reactNativeAndroidRoot')) {
-        defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
-    } else {
-        defaultDir = new File(
-                projectDir,
-                '/../../../node_modules/react-native/android'
-        )
+  buildTypes {
+    release {
+      minifyEnabled false
     }
+  }
 
-    if (defaultDir.exists()) {
-        maven {
-            url defaultDir.toString()
-            name androidSourcesName
-        }
-
-        logger.info(":${project.name}:reactNativeAndroidRoot ${defaultDir.canonicalPath}")
-        found = true
-    } else {
-        def parentDir = rootProject.projectDir
-
-        1.upto(5, {
-            if (found) return true
-            parentDir = parentDir.parentFile
-
-            def androidSourcesDir = new File(
-                    parentDir,
-                    'node_modules/react-native'
-            )
-
-            def androidPrebuiltBinaryDir = new File(
-                    parentDir,
-                    'node_modules/react-native/android'
-            )
-
-            if (androidPrebuiltBinaryDir.exists()) {
-                maven {
-                    url androidPrebuiltBinaryDir.toString()
-                    name androidSourcesName
-                }
-
-                logger.info(":${project.name}:reactNativeAndroidRoot ${androidPrebuiltBinaryDir.canonicalPath}")
-                found = true
-            } else if (androidSourcesDir.exists()) {
-                maven {
-                    url androidSourcesDir.toString()
-                    name androidSourcesName
-                }
-
-                logger.info(":${project.name}:reactNativeAndroidRoot ${androidSourcesDir.canonicalPath}")
-                found = true
-            }
-        })
-    }
+  lintOptions {
+    disable "GradleCompatible"
+  }
 
-    if (!found) {
-        throw new GradleException(
-                "${project.name}: unable to locate React Native android sources. " +
-                        "Ensure you have you installed React Native as a dependency in your project and try again."
-        )
-    }
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
 }
 
-dependencies {
-    //noinspection GradleDynamicVersion
-    implementation 'com.facebook.react:react-native:+'
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation 'androidx.appcompat:appcompat:1.5.1'
-    implementation 'androidx.appcompat:appcompat-resources:1.5.1'
-    implementation 'com.google.android.gms:play-services-wallet:19.1.0'
-    implementation 'androidx.core:core-ktx:1.9.0'
-    implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.1.0'
-
-    implementation 'com.judopay:judokit-android:4.1.2'
-
-    //JUnit 5
-    testImplementation "org.junit.jupiter:junit-jupiter-api:$junit5_version"
-    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:$junit5_version"
-    testImplementation "org.junit.jupiter:junit-jupiter-params:$junit5_version"
-    testRuntimeOnly "org.junit.vintage:junit-vintage-engine:$junit5_version"
-
-    testImplementation 'androidx.test:core:1.5.0'
-    testImplementation 'io.mockk:mockk:1.13.3'
-    testImplementation 'android.arch.core:core-testing:1.1.1'
-}
-
-if (isNewArchitectureEnabled()) {
-    react {
-        jsRootDir = file("../src/")
-        libraryName = "JudoKit-ReactNative"
-        codegenJavaPackageName = "com.reactlibrary"
-    }
-}
-
-task generateCodeAnalysisReport {
-    group 'Reporting'
-    description 'Start reporting code analysis tasks (Jacoco)'
-    dependsOn ":jacocoTestReport"
+repositories {
+  mavenCentral()
+  google()
 }
 
-task jacocoTestReport(type: JacocoReport, group: 'verification', description: 'Generate Jacoco Reports for all android variants')
+def kotlin_version = getExtOrDefault("kotlinVersion")
+def judokit_android_version = getExtOrDefault("judoKitAndroidVersion")
 
-project.afterEvaluate {
-    def variants = android.hasProperty('libraryVariants') ? android.libraryVariants : android.applicationVariants
-    variants.forEach {
-        tasks.jacocoTestReport.dependsOn(addJacocoTask(it))
-    }
+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:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "com.judopay:judokit-android:$judokit_android_version"
 }
 
-def addJacocoTask(variant) {
-    def variantName = variant.name.capitalize()
-    logger.info("Adding jacoco task for variant $variantName")
-
-    // see https://docs.gradle.org/current/dsl/org.gradle.testing.jacoco.tasks.JacocoReport.html
-    def taskName = "jacocoTestReport${variantName}"
-    def foundTask = project.tasks.findByName(taskName)
-    def jacocoTask = foundTask ? foundTask : project.tasks.create(taskName, JacocoReport)
-
-    jacocoTask.dependsOn("test${variantName}UnitTest")
-    jacocoTask.group = 'verification'
-    jacocoTask.description = "Generate Jacoco Report for variant $variantName"
-
-    jacocoTask.reports {
-        csv.enabled false
-        html.enabled true
-        xml.enabled true
-    }
-
-    def excludedFiles = [
-            '**/R.class',
-            '**/R$*.class',
-            '**/BuildConfig.*',
-            '**/Manifest*.*',
-            '**/*test*.*',
-            'android/**/*.*'
-    ]
-
-    def sourceDirectories = files(variant.sourceSets.java.srcDirs.flatten())
-    def classDirectories = fileTree(dir: variant.javaCompileProvider.get().destinationDir, excludes: excludedFiles)
-
-    if (project.plugins.hasPlugin("kotlin-android")) {
-        sourceDirectories.from(files(variant.sourceSets.kotlin.srcDirs.flatten()))
-        def kotlinTask = tasks.getByName("compile${variantName}Kotlin")
-        if (kotlinTask) {
-            classDirectories += fileTree(dir: kotlinTask.destinationDirectory, excludes: excludedFiles)
-        }
-    }
-
-    jacocoTask.sourceDirectories.from = sourceDirectories
-    jacocoTask.classDirectories.from = classDirectories
-    jacocoTask.executionData.from = files("${buildDir}/jacoco/test${variantName}UnitTest.exec")
-    jacocoTask
-}

package/android/gradle.properties

@@ -1 +1,6 @@
-android.useAndroidX=true
+JudoKitReactNative_kotlinVersion=1.7.0
+JudoKitReactNative_minSdkVersion=21
+JudoKitReactNative_targetSdkVersion=31
+JudoKitReactNative_compileSdkVersion=31
+JudoKitReactNative_ndkversion=21.4.7075529
+JudoKitReactNative_judoKitAndroidVersion=4.2.1

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1,3 @@
-<manifest package="com.reactlibrary">
-
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.judopay.judokit.reactnative">
 </manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>