react-native-nitro-cookies 0.0.1

package/NitroCookies.podspec

@@ -0,0 +1,30 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroCookies"
+  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 }
+  s.source       = { :git => "https://github.com/l2hyunwoo/react-native-nitro-cookies.git", :tag => "#{s.version}" }
+
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+
+  load 'nitrogen/generated/ios/NitroCookies+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(nitrocookies)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME nitrocookies)
+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/nitrocookies+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,128 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['NitroCookies_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/nitrocookies+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroCookies_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.nitrocookies"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -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 {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroCookies_kotlinVersion=2.0.21
+NitroCookies_minSdkVersion=24
+NitroCookies_targetSdkVersion=34
+NitroCookies_compileSdkVersion=35
+NitroCookies_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,6 @@
+#include <jni.h>
+#include "nitrocookiesOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::nitrocookies::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/nitrocookies/NitroCookies.kt

@@ -0,0 +1,340 @@
+package com.margelo.nitro.nitrocookies
+
+import android.webkit.CookieManager
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+import java.net.HttpURLConnection
+import java.net.URL
+import java.text.SimpleDateFormat
+import java.util.Locale
+import java.util.TimeZone
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+/** HybridNitroCookies - Android implementation of cookie management */
+@DoNotStrip
+class NitroCookies : HybridNitroCookiesSpec() {
+
+  /** Convert Cookie struct to Set-Cookie header string */
+  private fun toRFC6265String(cookie: Cookie): String {
+    val parts = mutableListOf<String>()
+
+    // Name=Value (required)
+    parts.add("${cookie.name}=${cookie.value}")
+
+    // Path attribute
+    cookie.path?.let { parts.add("Path=$it") }
+
+    // Domain attribute
+    cookie.domain?.let { parts.add("Domain=$it") }
+
+    // Expires attribute (convert ISO 8601 to RFC 1123)
+    cookie.expires?.let { expiresISO ->
+      try {
+        val date = iso8601Formatter.parse(expiresISO)
+        date?.let {
+          val expiresRFC = rfc1123Formatter.format(it)
+          parts.add("Expires=$expiresRFC")
+        }
+      } catch (e: Exception) {
+        // Invalid date format, skip expires
+      }
+    }
+
+    // Secure flag
+    if (cookie.secure == true) {
+      parts.add("Secure")
+    }
+
+    // HttpOnly flag
+    if (cookie.httpOnly == true) {
+      parts.add("HttpOnly")
+    }
+
+    return parts.joinToString("; ")
+  }
+
+  /** Parse a Set-Cookie header string into Cookie struct */
+  private fun createCookieData(setCookieHeader: String, url: URL): Cookie? {
+    val parts = setCookieHeader.split(";").map { it.trim() }
+    if (parts.isEmpty()) return null
+
+    // First part is name=value
+    val nameValue = parts[0].split("=", limit = 2)
+    if (nameValue.size != 2) return null
+
+    val name = nameValue[0].trim()
+    val value = nameValue[1].trim()
+
+    var path: String? = null
+    var domain: String? = null
+    var expires: String? = null
+    var secure: Boolean? = null
+    var httpOnly: Boolean? = null
+
+    // Parse attributes
+    for (i in 1 until parts.size) {
+      val part = parts[i]
+      when {
+        part.startsWith("Path=", ignoreCase = true) -> {
+          path = part.substring(5).trim()
+        }
+
+        part.startsWith("Domain=", ignoreCase = true) -> {
+          domain = part.substring(7).trim()
+        }
+
+        part.startsWith("Expires=", ignoreCase = true) -> {
+          val expiresRFC = part.substring(8).trim()
+          try {
+            val date = rfc1123Formatter.parse(expiresRFC)
+            date?.let { expires = iso8601Formatter.format(it) }
+          } catch (e: Exception) {
+            // Invalid date, skip
+          }
+        }
+
+        part.equals("Secure", ignoreCase = true) -> {
+          secure = true
+        }
+
+        part.equals("HttpOnly", ignoreCase = true) -> {
+          httpOnly = true
+        }
+      }
+    }
+
+    // Apply defaults
+    if (path == null) path = "/"
+    if (domain == null) domain = url.host
+
+    return Cookie(
+      name = name,
+      value = value,
+      path = path,
+      domain = domain,
+      version = null,
+      expires = expires,
+      secure = secure,
+      httpOnly = httpOnly
+    )
+  }
+
+  /** Check if cookie domain matches or is subdomain of URL host Similar to iOS isMatchingDomain */
+  private fun isMatchingDomain(cookieDomain: String, urlHost: String): Boolean {
+    // Exact match
+    if (cookieDomain == urlHost) {
+      return true
+    }
+
+    // Wildcard match (.example.com matches api.example.com)
+    if (cookieDomain.startsWith(".")) {
+      val domain = cookieDomain.substring(1)
+      return urlHost.endsWith(domain) || urlHost == domain
+    }
+
+    // Subdomain match (example.com matches api.example.com)
+    return urlHost.endsWith(".$cookieDomain")
+  }
+
+  /** Validate that cookie domain matches URL host */
+  private fun validateDomain(cookie: Cookie, url: URL) {
+    val host = url.host ?: throw Exception("INVALID_URL: URL has no host")
+    val cookieDomain = cookie.domain ?: host
+
+    if (!isMatchingDomain(cookieDomain, host)) {
+      throw Exception(
+        "DOMAIN_MISMATCH: Cookie domain '$cookieDomain' does not match URL host '$host'"
+      )
+    }
+  }
+
+  /** Validate URL has protocol (http:// or https://) */
+  private fun validateURL(urlString: String): URL {
+    val url =
+      try {
+        URL(urlString)
+      } catch (e: Exception) {
+        throw Exception(
+          "INVALID_URL: Invalid URL: '$urlString'. URLs must include protocol (http:// or https://)"
+        )
+      }
+
+    if (url.protocol != "http" && url.protocol != "https") {
+      throw Exception(
+        "INVALID_URL: Invalid URL: '$urlString'. URLs must include protocol (http:// or https://)"
+      )
+    }
+
+    return url
+  }
+
+  // MARK: - Main Cookie Operations
+
+  /** Set a single cookie */
+  override fun set(url: String, cookie: Cookie, useWebKit: Boolean?): Promise<Boolean> {
+    return Promise.async {
+      val urlObj = validateURL(url)
+      validateDomain(cookie, urlObj)
+
+      // Apply defaults
+      val cookieWithDefaults =
+        cookie.copy(path = cookie.path ?: "/", domain = cookie.domain ?: urlObj.host)
+
+      val cookieManager = CookieManager.getInstance()
+      cookieManager.setAcceptCookie(true)
+
+      val setCookieString = toRFC6265String(cookieWithDefaults)
+      cookieManager.setCookie(url, setCookieString)
+
+      true
+    }
+  }
+
+  /** Get all cookies for a URL */
+  override fun get(url: String, useWebKit: Boolean?): Promise<Array<Cookie>> {
+    return Promise.async {
+      val urlObj = validateURL(url)
+      val cookieManager = CookieManager.getInstance()
+      val cookieString = cookieManager.getCookie(url)
+
+      if (cookieString.isNullOrEmpty()) {
+        return@async emptyArray()
+      }
+
+      // Parse cookie string (format: "name1=value1; name2=value2")
+      val cookies = mutableListOf<Cookie>()
+      val cookiePairs = cookieString.split(";").map { it.trim() }
+
+      for (pair in cookiePairs) {
+        val nameValue = pair.split("=", limit = 2)
+        if (nameValue.size == 2) {
+          cookies.add(
+            Cookie(
+              name = nameValue[0].trim(),
+              value = nameValue[1].trim(),
+              path = "/",
+              domain = urlObj.host,
+              version = null,
+              expires = null,
+              secure = null,
+              httpOnly = null
+            )
+          )
+        }
+      }
+
+      cookies.toTypedArray()
+    }
+  }
+
+  /** Clear all cookies */
+  override fun clearAll(useWebKit: Boolean?): Promise<Boolean> {
+    return Promise.async {
+      val cookieManager = CookieManager.getInstance()
+      suspendCoroutine { continuation ->
+        cookieManager.removeAllCookies { success -> continuation.resume(success) }
+      }
+    }
+  }
+
+  /** Parse and set cookies from Set-Cookie header */
+  override fun setFromResponse(url: String, value: String): Promise<Boolean> {
+    return Promise.async {
+      val urlObj = validateURL(url)
+      val cookieManager = CookieManager.getInstance()
+      cookieManager.setAcceptCookie(true)
+
+      // Set-Cookie header can contain multiple cookies
+      val setCookieHeaders = value.split("\n").map { it.trim() }
+      for (header in setCookieHeaders) {
+        if (header.isNotEmpty()) {
+          cookieManager.setCookie(url, header)
+        }
+      }
+
+      true
+    }
+  }
+
+  /** Make HTTP request and get cookies from response */
+  override fun getFromResponse(url: String): Promise<Array<Cookie>> {
+    return Promise.async {
+      try {
+        val urlObj = validateURL(url)
+        val connection = urlObj.openConnection() as HttpURLConnection
+        connection.requestMethod = "GET"
+        connection.connect()
+
+        val cookies = mutableListOf<Cookie>()
+        val setCookieHeaders = connection.headerFields["Set-Cookie"] ?: emptyList()
+
+        for (header in setCookieHeaders) {
+          val cookie = createCookieData(header, urlObj)
+          cookie?.let { cookies.add(it) }
+        }
+
+        connection.disconnect()
+        cookies.toTypedArray()
+      } catch (e: Exception) {
+        throw Exception("NETWORK_ERROR: ${e.message}")
+      }
+    }
+  }
+
+  /** Get all cookies regardless of domain (iOS only - not supported on Android) */
+  override fun getAll(useWebKit: Boolean?): Promise<Array<Cookie>> {
+    return Promise.async {
+      throw Exception("PLATFORM_UNSUPPORTED: getAll() is only available on iOS")
+    }
+  }
+
+  /** Clear specific cookie by name (iOS only - not fully supported on Android) */
+  override fun clearByName(url: String, name: String, useWebKit: Boolean?): Promise<Boolean> {
+    return Promise.async {
+      val urlObj = validateURL(url)
+      val cookieManager = CookieManager.getInstance()
+
+      // Android CookieManager doesn't support removing specific cookies by name
+      // We can only expire them by setting a past expiration date
+      val expiredCookie =
+        "$name=; Path=/; Domain=${urlObj.host}; Expires=Thu, 01 Jan 1970 00:00:00 GMT"
+      cookieManager.setCookie(url, expiredCookie)
+
+      true
+    }
+  }
+
+  /** Flush cookies to persistent storage (Android only) */
+  override fun flush(): Promise<Unit> {
+    return Promise.async {
+      val cookieManager = CookieManager.getInstance()
+      cookieManager.flush()
+      Unit
+    }
+  }
+
+  /** Remove session cookies (Android only) */
+  override fun removeSessionCookies(): Promise<Boolean> {
+    return Promise.async {
+      val cookieManager = CookieManager.getInstance()
+      suspendCoroutine { continuation ->
+        cookieManager.removeSessionCookies { success -> continuation.resume(success) }
+      }
+    }
+  }
+
+  companion object {
+    /** ISO 8601 date formatter for cookie expires (yyyy-MM-dd'T'HH:mm:ss.SSSZZZZZ) */
+    private val iso8601Formatter =
+      SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZZZZZ", Locale.US).apply {
+        timeZone = TimeZone.getTimeZone("UTC")
+      }
+
+    /** RFC 1123 date formatter for Set-Cookie headers (EEE, dd MMM yyyy HH:mm:ss z) */
+    private val rfc1123Formatter =
+      SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US).apply {
+        timeZone = TimeZone.getTimeZone("GMT")
+      }
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitrocookies/NitroCookiesPackage.kt

@@ -0,0 +1,22 @@
+package com.margelo.nitro.nitrocookies
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class NitroCookiesPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return null
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider { HashMap() }
+  }
+
+  companion object {
+    init {
+      System.loadLibrary("nitrocookies")
+    }
+  }
+}