react-native-iap 15.3.5 → 15.4.0-rc.1

package/src/vega.kepler.ts

@@ -0,0 +1,21 @@
+import {Platform} from 'react-native';
+// eslint-disable-next-line import/no-unresolved
+import {PurchasingService} from '@amazon-devices/keplerscript-appstore-iap-lib';
+import type {RnIap} from './specs/RnIap.nitro';
+import {createVegaIapModule, type VegaPurchasingService} from './vega-adapter';
+
+let cachedVegaModule: RnIap | null = null;
+
+export const isVegaOS = (): boolean => {
+  return String(Platform.OS).toLowerCase() === 'kepler';
+};
+
+export const getVegaIapModule = (): RnIap | null => {
+  if (!isVegaOS()) return null;
+  if (!cachedVegaModule) {
+    cachedVegaModule = createVegaIapModule(
+      PurchasingService as unknown as VegaPurchasingService,
+    );
+  }
+  return cachedVegaModule;
+};

package/src/vega.ts

@@ -0,0 +1,10 @@
+import {Platform} from 'react-native';
+import type {RnIap} from './specs/RnIap.nitro';
+
+export const isVegaOS = (): boolean => {
+  return String(Platform.OS).toLowerCase() === 'kepler';
+};
+
+export const getVegaIapModule = (): RnIap | null => {
+  return null;
+};

package/android/src/test/java/com/margelo/nitro/iap/ListenerThreadSafetyTest.kt

@@ -1,154 +0,0 @@
-package com.margelo.nitro.iap
-
-import org.junit.Test
-import org.junit.Assert.*
-import java.util.concurrent.CyclicBarrier
-import java.util.concurrent.atomic.AtomicInteger
-import java.util.concurrent.atomic.AtomicReference
-import kotlin.concurrent.thread
-
-/**
- * Thread safety tests for the synchronized + snapshot listener pattern
- * used in HybridRnIap to prevent ConcurrentModificationException.
- *
- * Addresses Issue #3150 where purchase events were silently lost
- * due to concurrent listener access.
- */
-class ListenerThreadSafetyTest {
-
-    @Test
-    fun `concurrent add and snapshot iterate does not throw`() {
-        val listeners = mutableListOf<(String) -> Unit>()
-        val callCount = AtomicInteger(0)
-        val errorRef = AtomicReference<Throwable?>(null)
-        val iterations = 500
-        val barrier = CyclicBarrier(2)
-
-        val adder = thread {
-            barrier.await()
-            repeat(iterations) {
-                synchronized(listeners) { listeners.add { callCount.incrementAndGet() } }
-            }
-        }
-
-        val sender = thread {
-            barrier.await()
-            repeat(iterations) {
-                val snapshot = synchronized(listeners) { ArrayList(listeners) }
-                snapshot.forEach {
-                    try {
-                        it("event")
-                    } catch (e: Throwable) {
-                        errorRef.compareAndSet(null, e)
-                    }
-                }
-            }
-        }
-
-        adder.join(5000)
-        sender.join(5000)
-        assertFalse("Adder thread did not finish", adder.isAlive)
-        assertFalse("Sender thread did not finish", sender.isAlive)
-        assertNull("Should not throw ConcurrentModificationException", errorRef.get())
-    }
-
-    @Test
-    fun `concurrent add, remove, and iterate is safe`() {
-        val listeners = mutableListOf<(String) -> Unit>()
-        val errorRef = AtomicReference<Throwable?>(null)
-        val barrier = CyclicBarrier(3)
-
-        val adder = thread {
-            barrier.await()
-            repeat(200) {
-                synchronized(listeners) { listeners.add { _ -> } }
-            }
-        }
-
-        val remover = thread {
-            barrier.await()
-            repeat(200) {
-                synchronized(listeners) {
-                    if (listeners.isNotEmpty()) listeners.removeAt(0)
-                }
-            }
-        }
-
-        val sender = thread {
-            barrier.await()
-            repeat(200) {
-                val snapshot = synchronized(listeners) { ArrayList(listeners) }
-                snapshot.forEach {
-                    try {
-                        it("event")
-                    } catch (e: Throwable) {
-                        errorRef.compareAndSet(null, e)
-                    }
-                }
-            }
-        }
-
-        adder.join(5000)
-        remover.join(5000)
-        sender.join(5000)
-        assertFalse("Adder thread did not finish", adder.isAlive)
-        assertFalse("Remover thread did not finish", remover.isAlive)
-        assertFalse("Sender thread did not finish", sender.isAlive)
-        assertNull("Concurrent access should be safe with snapshot pattern", errorRef.get())
-    }
-
-    @Test
-    fun `snapshot delivers to all registered listeners`() {
-        val listeners = mutableListOf<(String) -> Unit>()
-        val results = mutableListOf<String>()
-
-        synchronized(listeners) {
-            listeners.add { results.add("listener1:$it") }
-            listeners.add { results.add("listener2:$it") }
-        }
-
-        val snapshot = synchronized(listeners) { ArrayList(listeners) }
-        snapshot.forEach { it("event") }
-
-        assertEquals(2, results.size)
-        assertTrue(results.contains("listener1:event"))
-        assertTrue(results.contains("listener2:event"))
-    }
-
-    @Test
-    fun `synchronized clear removes all listeners`() {
-        val listeners = mutableListOf<(String) -> Unit>()
-        synchronized(listeners) {
-            listeners.add { _ -> }
-            listeners.add { _ -> }
-        }
-
-        synchronized(listeners) { listeners.clear() }
-
-        val snapshot = synchronized(listeners) { ArrayList(listeners) }
-        assertTrue("Listeners should be empty after clear", snapshot.isEmpty())
-    }
-
-    @Test
-    fun `snapshot is isolated from subsequent modifications`() {
-        val listeners = mutableListOf<(String) -> Unit>()
-        val results = mutableListOf<String>()
-
-        synchronized(listeners) {
-            listeners.add { results.add("original:$it") }
-        }
-
-        // Take snapshot before adding more listeners
-        val snapshot = synchronized(listeners) { ArrayList(listeners) }
-
-        // Add another listener after snapshot
-        synchronized(listeners) {
-            listeners.add { results.add("added-after:$it") }
-        }
-
-        // Only the original listener should be in the snapshot
-        snapshot.forEach { it("event") }
-        assertEquals(1, results.size)
-        assertEquals("original:event", results[0])
-    }
-}

package/android/src/test/java/com/margelo/nitro/iap/OpenIapExceptionTest.kt

@@ -1,93 +0,0 @@
-package com.margelo.nitro.iap
-
-import org.junit.Test
-import org.junit.Assert.*
-
-/**
- * Unit tests for OpenIapException to verify that error messages
- * are returned without Java/Kotlin stack traces.
- *
- * This addresses Issue #3075 where error.code was undefined because
- * stack traces were breaking JSON parsing on the JavaScript side.
- */
-class OpenIapExceptionTest {
-
-    @Test
-    fun `test OpenIapException message returns clean JSON`() {
-        val errorJson = """{"code":"init-connection","message":"Failed to initialize connection"}"""
-        val exception = OpenIapException(errorJson)
-
-        // Verify message is exactly the JSON string
-        assertEquals(errorJson, exception.message)
-    }
-
-    @Test
-    fun `test OpenIapException toString returns clean JSON without stack trace`() {
-        val errorJson = """{"code":"user-cancelled","message":"User cancelled"}"""
-        val exception = OpenIapException(errorJson)
-
-        // toString() should return only the JSON, not "java.lang.Exception: ..."
-        val result = exception.toString()
-        assertEquals(errorJson, result)
-        assertFalse(result.startsWith("java.lang.Exception:"))
-        assertFalse(result.contains("\tat "))
-    }
-
-    @Test
-    fun `test thrown OpenIapException message is clean`() {
-        val errorJson = """{"code":"network-error","message":"Network error occurred","responseCode":-1}"""
-
-        try {
-            throw OpenIapException(errorJson)
-        } catch (e: Exception) {
-            // Verify the caught exception message is clean
-            assertEquals(errorJson, e.message)
-            assertEquals(errorJson, e.toString())
-        }
-    }
-
-    @Test
-    fun `test OpenIapException with complex JSON structure`() {
-        val errorJson = """{"code":"purchase-error","message":"Purchase failed","responseCode":3,"debugMessage":"Item unavailable","productId":"com.test.product"}"""
-        val exception = OpenIapException(errorJson)
-
-        assertEquals(errorJson, exception.message)
-        assertEquals(errorJson, exception.toString())
-    }
-
-    @Test
-    fun `test multiple OpenIapException instances are independent`() {
-        val error1 = """{"code":"error-1","message":"First error"}"""
-        val error2 = """{"code":"error-2","message":"Second error"}"""
-
-        val exception1 = OpenIapException(error1)
-        val exception2 = OpenIapException(error2)
-
-        assertEquals(error1, exception1.message)
-        assertEquals(error2, exception2.message)
-        assertNotEquals(exception1.message, exception2.message)
-    }
-
-    @Test
-    fun `test OpenIapException with empty JSON`() {
-        val errorJson = """{}"""
-        val exception = OpenIapException(errorJson)
-
-        assertEquals(errorJson, exception.message)
-        assertEquals(errorJson, exception.toString())
-    }
-
-    @Test
-    fun `test OpenIapException message does not contain stack trace keywords`() {
-        val errorJson = """{"code":"test-error","message":"Test message"}"""
-        val exception = OpenIapException(errorJson)
-
-        val result = exception.toString()
-
-        // Verify no stack trace keywords are present
-        assertFalse("Should not contain 'at ' (stack trace)", result.contains("\tat "))
-        assertFalse("Should not contain 'java.lang.Exception:'", result.contains("java.lang.Exception:"))
-        assertFalse("Should not contain '.kt:' (Kotlin file reference)", result.contains(".kt:"))
-        assertFalse("Should not contain '.java:' (Java file reference)", result.contains(".java:"))
-    }
-}

package/android/src/test/java/com/margelo/nitro/iap/ProductQueryHelpersTest.kt

@@ -1,140 +0,0 @@
-package com.margelo.nitro.iap
-
-import dev.hyo.openiap.IapPlatform
-import dev.hyo.openiap.OpenIapError
-import dev.hyo.openiap.ProductCommon
-import dev.hyo.openiap.ProductQueryType
-import dev.hyo.openiap.ProductType
-import java.util.Collections
-import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.withTimeout
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertSame
-import org.junit.Test
-
-class ProductQueryHelpersTest {
-    @Test
-    fun `all query starts in-app and subs fetches concurrently`() = runBlocking {
-        val startedKinds = Collections.synchronizedSet(mutableSetOf<ProductQueryType>())
-        val bothStarted = CompletableDeferred<Unit>()
-
-        val products = withTimeout(1000) {
-            collectAllQueryProducts(
-                skusList = listOf("monthly", "lifetime"),
-                fetchKind = { kind ->
-                    when (kind) {
-                        ProductQueryType.InApp,
-                        ProductQueryType.Subs -> {
-                            startedKinds.add(kind)
-                            if (startedKinds.size == 2) {
-                                bothStarted.complete(Unit)
-                            }
-                            bothStarted.await()
-
-                            when (kind) {
-                                ProductQueryType.InApp -> listOf(
-                                    fakeProduct("lifetime", ProductType.InApp),
-                                )
-                                ProductQueryType.Subs -> listOf(
-                                    fakeProduct("monthly", ProductType.Subs),
-                                )
-                                ProductQueryType.All -> error("All should be expanded by the helper")
-                            }
-                        }
-                        ProductQueryType.All -> error("All should be expanded by the helper")
-                    }
-                },
-            )
-        }
-
-        assertEquals(setOf(ProductQueryType.InApp, ProductQueryType.Subs), startedKinds.toSet())
-        assertEquals(listOf("monthly", "lifetime"), products.map { it.id })
-    }
-
-    @Test
-    fun `all query returns partial success when one product kind fails`() = runBlocking {
-        val queryError = OpenIapError.BillingError("Invalid subscriptions")
-        val failures = mutableListOf<Pair<ProductQueryType, Throwable>>()
-
-        val products = collectAllQueryProducts(
-            skusList = listOf("monthly", "lifetime"),
-            fetchKind = { kind ->
-                when (kind) {
-                    ProductQueryType.InApp -> listOf(fakeProduct("lifetime", ProductType.InApp))
-                    ProductQueryType.Subs -> throw queryError
-                    ProductQueryType.All -> error("All should be expanded by the helper")
-                }
-            },
-            onFailure = { kind, error -> failures += kind to error },
-        )
-
-        assertEquals(listOf("lifetime"), products.map { it.id })
-        assertEquals(listOf(ProductQueryType.Subs), failures.map { it.first })
-        assertSame(queryError, failures.single().second)
-    }
-
-    @Test
-    fun `all query rethrows first failure when both product kinds fail`() = runBlocking {
-        val firstError = OpenIapError.BillingError("Invalid in-app products")
-        val secondError = OpenIapError.BillingError("Service unavailable")
-        val failures = mutableListOf<ProductQueryType>()
-
-        try {
-            collectAllQueryProducts(
-                skusList = listOf("monthly", "lifetime"),
-                fetchKind = { kind ->
-                    when (kind) {
-                        ProductQueryType.InApp -> throw firstError
-                        ProductQueryType.Subs -> throw secondError
-                        ProductQueryType.All -> error("All should be expanded by the helper")
-                    }
-                },
-                onFailure = { kind, _ -> failures += kind },
-            )
-        } catch (error: Throwable) {
-            assertSame(firstError, error)
-            assertEquals(listOf(ProductQueryType.InApp, ProductQueryType.Subs), failures)
-            return@runBlocking
-        }
-
-        error("Expected the first product query failure to be rethrown")
-    }
-
-    @Test
-    fun `all query preserves input sku order and keeps first matching product`() = runBlocking {
-        val products = collectAllQueryProducts(
-            skusList = listOf("monthly", "lifetime", "annual"),
-            fetchKind = { kind ->
-                when (kind) {
-                    ProductQueryType.InApp -> listOf(
-                        fakeProduct("lifetime", ProductType.InApp),
-                        fakeProduct("monthly", ProductType.InApp),
-                    )
-                    ProductQueryType.Subs -> listOf(
-                        fakeProduct("monthly", ProductType.Subs),
-                        fakeProduct("annual", ProductType.Subs),
-                    )
-                    ProductQueryType.All -> error("All should be expanded by the helper")
-                }
-            },
-        )
-
-        assertEquals(listOf("monthly", "lifetime", "annual"), products.map { it.id })
-        assertEquals(ProductType.InApp, products[0].type)
-    }
-
-    private fun fakeProduct(productId: String, type: ProductType): ProductCommon =
-        object : ProductCommon {
-            override val currency: String = "USD"
-            override val debugDescription: String? = null
-            override val description: String = productId
-            override val displayName: String? = productId
-            override val displayPrice: String = "$1.00"
-            override val id: String = productId
-            override val platform: IapPlatform = IapPlatform.Android
-            override val price: Double? = 1.0
-            override val title: String = productId
-            override val type: ProductType = type
-        }
-}

package/plugin/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["./src/withIAP.ts"],"version":"5.9.2"}