react-native-nitro-version-check 0.0.1

package/NitroVersionCheck.podspec

@@ -0,0 +1,31 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroVersionCheck"
+  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/NitroVersionCheck+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,117 @@
+<h1 align="center">
+  react-native-nitro-version-check
+</h1>
+
+<p align="center">
+  <b>A fast, modern version-checking library for React Native, powered by <a href="https://github.com/mrousavy/nitro">Nitro Modules</a>.</b>
+</p>
+
+<p align="center">
+  A drop-in replacement for the unmaintained <a href="https://github.com/kimxogus/react-native-version-check"><code>react-native-version-check</code></a> — rewritten from scratch with <a href="https://github.com/mrousavy/nitro">Nitro Modules</a>.
+</p>
+
+<br />
+
+## Features
+
+- ⚡ **Synchronous access** to version, build number, package name, and country
+- 🏪 **Store version lookup** from the App Store or Play Store
+- 🔍 **Granular update checks** — major, minor, or patch
+- 📦 **Install source detection** — TestFlight, App Store, Play Store, or sideloaded
+- 🪶 **Tiny footprint** — pure Swift on iOS, Kotlin on Android
+
+## Performance
+
+Benchmarked against [`react-native-version-check`](https://github.com/kimxogus/react-native-version-check). 100,000 iterations averaged over 5 runs on an iPhone 12:
+
+| Method | Speedup |
+|--------|---------|
+| `getAllInfo` | **~3.1x faster** |
+| `packageName` | **~1.6x faster** |
+| `version` | **~1.6x faster** |
+| `buildNumber` | **~1.6x faster** |
+| `getCountry` | **~3.1x faster** |
+
+## Installation
+
+```sh
+bun add react-native-nitro-version-check react-native-nitro-modules
+```
+
+For Expo projects, run prebuild:
+```sh
+npx expo prebuild
+```
+
+For bare React Native projects:
+```sh
+cd ios && pod install
+```
+
+## Usage
+
+```ts
+import { VersionCheck, getCountry, getStoreUrl, getLatestVersion, needsUpdate } from 'react-native-nitro-version-check'
+
+// Sync properties
+VersionCheck.version       // "1.2.0"
+VersionCheck.buildNumber   // "42"
+VersionCheck.packageName   // "com.example.app"
+VersionCheck.installSource // "appstore" | "testflight" | "playstore" | undefined
+getCountry()               // "US"
+
+// Async
+const url    = await getStoreUrl()       // App Store / Play Store URL
+const latest = await getLatestVersion()  // "1.3.0"
+
+if (await needsUpdate()) {
+  Linking.openURL(await getStoreUrl())
+}
+
+// Only prompt for major updates
+if (await needsUpdate({ level: 'major' })) {
+  // 1.x → 2.x
+}
+```
+
+## API
+
+### `VersionCheck`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `version` | `string` | App version |
+| `buildNumber` | `string` | Build number |
+| `packageName` | `string` | Bundle ID / Application ID |
+| `installSource` | `string \| undefined` | `"appstore"` `"testflight"` `"playstore"` or `undefined` |
+| `getCountry()` | `string` | Device's 2-letter ISO country code |
+| `getStoreUrl()` | `Promise<string>` | App Store / Play Store URL |
+| `getLatestVersion()` | `Promise<string>` | Latest version in the store |
+| `needsUpdate()` | `Promise<boolean>` | Whether an update is available |
+
+### Standalone exports
+
+Also available as individual named exports:
+
+| Export | Returns | Description |
+|--------|---------|-------------|
+| `getCountry()` | `string` | Device's 2-letter ISO country code |
+| `getStoreUrl()` | `Promise<string>` | App Store / Play Store URL |
+| `getLatestVersion()` | `Promise<string>` | Latest version in the store |
+| `needsUpdate(options?)` | `Promise<boolean>` | Whether an update is available |
+
+#### `needsUpdate` options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `level` | `"major" \| "minor" \| "patch"` | `"patch"` | Minimum version bump to trigger `true` |
+
+### Utilities
+
+| Function | Returns | Description |
+|----------|---------|-------------|
+| `compareVersions(v1, v2)` | `-1 \| 0 \| 1` | Compare two semver strings |
+
+## License
+
+MIT

package/android/CMakeLists.txt

@@ -0,0 +1,29 @@
+project(NitroVersionCheck)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME NitroVersionCheck)
+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/NitroVersionCheck+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,142 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:9.0.1"
+  }
+}
+
+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/NitroVersionCheck+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["NitroVersionCheck_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroVersionCheck_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.nitroversioncheck"
+
+  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",
+            "**/libNitroModules.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")
+}
+

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())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroVersionCheck_kotlinVersion=2.1.20
+NitroVersionCheck_minSdkVersion=23
+NitroVersionCheck_targetSdkVersion=36
+NitroVersionCheck_compileSdkVersion=36
+NitroVersionCheck_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,9 @@
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include "NitroVersionCheckOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::nitroversioncheck::registerAllNatives();
+  });
+}

package/android/src/main/java/com/margelo/nitro/nitroversioncheck/HybridVersionCheck.kt

@@ -0,0 +1,74 @@
+package com.margelo.nitro.nitroversioncheck
+
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import java.net.HttpURLConnection
+import java.net.URL
+
+class HybridVersionCheck : HybridVersionCheckSpec() {
+    companion object {
+        private const val TIMEOUT_MS = 15_000
+        private val context = NitroModules.applicationContext
+        private val packageInfo = context?.packageManager?.getPackageInfo(context.packageName, 0)
+    }
+
+    public override val version = packageInfo?.versionName ?: "unknown"
+
+    public override val buildNumber = if (android.os.Build.VERSION.SDK_INT >= 28) {
+        if (packageInfo?.longVersionCode != null) packageInfo.longVersionCode.toString() else "unknown"
+    } else {
+        @Suppress("DEPRECATION")
+        if (packageInfo?.versionCode != null) packageInfo.versionCode.toString() else "unknown"
+    }
+
+    public override val packageName = packageInfo?.packageName ?: "unknown"
+    public override val installSource: String? = run {
+        val installer = if (android.os.Build.VERSION.SDK_INT >= 30) {
+            context?.packageManager?.getInstallSourceInfo(context.packageName)?.installingPackageName
+        } else {
+            @Suppress("DEPRECATION")
+            context?.packageManager?.getInstallerPackageName(context.packageName)
+        }
+        if (installer != null) "playstore" else null
+    }
+
+    override fun getCountry(): String {
+        return java.util.Locale.getDefault().country ?: "unknown"
+    }
+
+    override fun getStoreUrl(): Promise<String> {
+        return Promise.async {
+            "https://play.google.com/store/apps/details?id=$packageName"
+        }
+    }
+
+    override fun getLatestVersion(): Promise<String> {
+        return Promise.async {
+            try {
+                val url = URL("https://play.google.com/store/apps/details?id=$packageName&hl=en")
+                val connection = url.openConnection() as HttpURLConnection
+                connection.connectTimeout = TIMEOUT_MS
+                connection.readTimeout = TIMEOUT_MS
+                connection.setRequestProperty("User-Agent", "Mozilla/5.0")
+                val html = connection.inputStream.bufferedReader().use { it.readText() }
+                val regex = Regex("""\]\]\],\s*"(\d+\.\d+[\d.]*\d)"""")
+                val match = regex.find(html)
+                match?.groupValues?.get(1)
+                    ?: throw Exception("Could not parse latest version from Play Store page")
+            } catch (e: Exception) {
+                throw Exception("Failed to fetch latest version: ${e.message}", e)
+            }
+        }
+    }
+
+    override fun needsUpdate(): Promise<Boolean> {
+        return Promise.async {
+            try {
+                val latest = getLatestVersion().await()
+                version != latest
+            } catch (e: Exception) {
+                throw Exception("Failed to check for updates: ${e.message}", e)
+            }
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/nitroversioncheck/NitroVersionCheckPackage.kt

@@ -0,0 +1,18 @@
+package com.margelo.nitro.nitroversioncheck
+
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.BaseReactPackage
+
+class NitroVersionCheckPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
+
+    companion object {
+        init {
+            NitroVersionCheckOnLoad.initializeNative()
+        }
+    }
+}

package/ios/Bridge.h

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

package/ios/HybridVersionCheck.swift

@@ -0,0 +1,71 @@
+import Foundation
+import NitroModules
+
+class HybridVersionCheck: HybridVersionCheckSpec {
+    private static let session: URLSession = {
+        let config = URLSessionConfiguration.default
+        config.timeoutIntervalForRequest = 15
+        config.timeoutIntervalForResource = 30
+        return URLSession(configuration: config)
+    }()
+
+    var version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown"
+    var buildNumber = Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? "unknown"
+    var packageName = Bundle.main.infoDictionary?["CFBundleIdentifier"] as? String ?? "unknown"
+    var installSource: String? = {
+        guard let receiptURL = Bundle.main.appStoreReceiptURL,
+              FileManager.default.fileExists(atPath: receiptURL.path) else {
+            return nil
+        }
+        if receiptURL.lastPathComponent == "sandboxReceipt" {
+            return "testflight"
+        }
+        return "appstore"
+    }()
+
+    func getCountry() throws -> String {
+        if #available(iOS 16, *) {
+            return Locale.current.region?.identifier ?? "unknown"
+        }
+        return Locale.current.regionCode ?? "unknown"
+    }
+
+    func getStoreUrl() throws -> Promise<String> {
+        return Promise.async {
+            let bundleId = Bundle.main.bundleIdentifier ?? ""
+            let url = URL(string: "https://itunes.apple.com/lookup?bundleId=\(bundleId)")!
+            let (data, _) = try await HybridVersionCheck.session.data(from: url)
+            guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+                  let results = json["results"] as? [[String: Any]],
+                  let trackViewUrl = results.first?["trackViewUrl"] as? String else {
+                throw NSError(domain: "VersionCheck", code: 1, userInfo: [NSLocalizedDescriptionKey: "App not found on App Store"])
+            }
+            return trackViewUrl
+        }
+    }
+
+    func getLatestVersion() throws -> Promise<String> {
+        return Promise.async {
+            let bundleId = Bundle.main.bundleIdentifier ?? ""
+            let url = URL(string: "https://itunes.apple.com/lookup?bundleId=\(bundleId)")!
+            let (data, _) = try await HybridVersionCheck.session.data(from: url)
+            guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+                  let results = json["results"] as? [[String: Any]],
+                  let latestVersion = results.first?["version"] as? String else {
+                throw NSError(domain: "VersionCheck", code: 2, userInfo: [NSLocalizedDescriptionKey: "App not found on App Store"])
+            }
+            return latestVersion
+        }
+    }
+
+    func needsUpdate() throws -> Promise<Bool> {
+        return Promise.async { [self] in
+            do {
+                let latest = try await self.getLatestVersion().await()
+                return self.version != latest
+            } catch {
+                throw NSError(domain: "VersionCheck", code: 3, userInfo: [NSLocalizedDescriptionKey: "Failed to check for updates: \(error.localizedDescription)"])
+            }
+        }
+    }
+}