@encorekit/react-native 1.1.15

package/README.md

@@ -0,0 +1,201 @@
+# Encore React Native SDK
+
+Thin React Native bridge to the native [Encore iOS SDK](https://github.com/EncoreKit/ios-sdk) and [Encore Android SDK](https://github.com/EncoreKit/android-sdk). Presents retention offers with native UI and delegates purchases to your existing subscription manager.
+
+## Installation
+
+```bash
+npm install @encorekit/react-native
+```
+
+### iOS
+
+```bash
+cd ios && pod install
+```
+
+### Android
+
+No additional setup required — `com.encorekit:encore` resolves from Maven Central, which is included by default in Android projects. The React Native module auto-links with RN 0.60+.
+
+## Quick Start
+
+### 1. Wrap Your App with EncoreProvider
+
+```tsx
+import { EncoreProvider } from '@encorekit/react-native';
+
+export default function App() {
+  return (
+    <EncoreProvider apiKey="your_api_key" options={{ logLevel: 'debug' }}>
+      <YourApp />
+    </EncoreProvider>
+  );
+}
+```
+
+The provider calls `configure` and `registerCallbacks` once on mount.
+
+### 2. Identify Users
+
+```tsx
+import Encore from '@encorekit/react-native';
+
+// After authentication
+Encore.identify('user_123', {
+  email: 'user@example.com',
+  subscriptionTier: 'premium',
+});
+
+// On logout
+Encore.reset();
+```
+
+### 3. Show a Placement
+
+```tsx
+const result = await Encore.show('paywall');
+// result.status: 'granted' | 'not_granted' | 'completed' | 'dismissed' | 'no_offers'
+```
+
+### 4. Handle Callbacks
+
+```tsx
+// Purchase request — delegate to your subscription manager
+Encore.onPurchaseRequest(async ({ requestId, productId, placementId }) => {
+  try {
+    await RevenueCat.purchase(productId);
+    await Encore.completePurchaseRequest(requestId, true);
+  } catch {
+    await Encore.completePurchaseRequest(requestId, false);
+  }
+});
+
+// Passthrough — user dismissed without purchasing
+Encore.onPassthrough(({ placementId }) => {
+  // Resume your original flow
+});
+
+// Purchase complete (fire-and-forget, for syncing with backends)
+Encore.onPurchaseComplete(({ productId, transactionId }) => {
+  console.log('Purchase completed:', productId);
+});
+```
+
+Each `on*` method returns an unsubscribe function:
+
+```tsx
+const unsubscribe = Encore.onPassthrough(handler);
+// Later:
+unsubscribe();
+```
+
+## API Reference
+
+### `configure(apiKey, options?)`
+
+Initialize the SDK. Called automatically by `EncoreProvider`.
+
+| Parameter | Type | Description |
+|:----------|:-----|:------------|
+| `apiKey` | `string` | Your Encore API key |
+| `options.logLevel` | `'none' \| 'error' \| 'warn' \| 'info' \| 'debug'` | Log verbosity (default: `'none'`) |
+
+### `identify(userId, attributes?)`
+
+Associate a user ID with SDK events.
+
+### `setUserAttributes(attributes)`
+
+Merge attributes into the current user profile.
+
+### `reset()`
+
+Clear user data and generate a new anonymous ID. Call on logout.
+
+### `show(placementId)`
+
+Present a native offer sheet. Returns `PlacementResult`.
+
+### `registerCallbacks()`
+
+Register native event handlers (purchase request, purchase complete, passthrough). Called automatically by `EncoreProvider`.
+
+### `completePurchaseRequest(requestId, success)`
+
+Signal completion of a purchase request initiated via `onPurchaseRequest`. The native SDK waits for this call before proceeding.
+
+### `onPurchaseRequest(handler)`
+
+Subscribe to purchase request events. Your handler receives `{ requestId, productId, placementId }` and must call `completePurchaseRequest` when done.
+
+### `onPurchaseComplete(handler)`
+
+Subscribe to purchase completion events. Receives `{ productId, transactionId }`.
+
+### `onPassthrough(handler)`
+
+Subscribe to passthrough events (user dismissed without purchasing). Receives `{ placementId }`.
+
+### `EncoreProvider`
+
+React context provider. Props:
+
+| Prop | Type | Description |
+|:-----|:-----|:------------|
+| `apiKey` | `string` | Your Encore API key |
+| `options` | `ConfigureOptions` | Optional configuration |
+
+### `useEncoreContext()`
+
+Hook returning the full `EncoreSDK` interface. Must be used within `EncoreProvider`.
+
+## Types
+
+```typescript
+interface UserAttributes {
+  email?: string;
+  firstName?: string;
+  lastName?: string;
+  phoneNumber?: string;
+  postalCode?: string;
+  city?: string;
+  state?: string;
+  countryCode?: string;
+  latitude?: string;
+  longitude?: string;
+  dateOfBirth?: string;
+  gender?: string;
+  language?: string;
+  subscriptionTier?: string;
+  monthsSubscribed?: string;
+  billingCycle?: string;
+  lastPaymentAmount?: string;
+  lastActiveDate?: string;
+  totalSessions?: string;
+  custom?: Record<string, string>;
+}
+
+interface PlacementResult {
+  status: 'granted' | 'not_granted' | 'completed' | 'dismissed' | 'no_offers';
+  reason?: string;
+  entitlement?: string;
+  offerId?: string;
+  campaignId?: string;
+}
+```
+
+## Requirements
+
+- React Native 0.60+
+- iOS 15.0+
+- Android API 21+
+- Node 16+
+
+## Note on Entitlements
+
+Entitlement tracking is handled by the native SDKs and your subscription manager. The React Native bridge does not expose entitlement query methods directly — use your subscription manager's React Native SDK (RevenueCat, Adapty, etc.) for entitlement checks.
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,80 @@
+import groovy.json.JsonSlurper
+
+def packageJson = new JsonSlurper().parseText(file("$projectDir/../package.json").text)
+def encoreAndroidVersion = packageJson.sdkVersions.android["com.encorekit:encore"]
+
+buildscript {
+    ext.safeExtGet = {prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+def getExtOrDefault(name) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["EncoreReactSDK_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["EncoreReactSDK_" + name]).toInteger()
+}
+
+android {
+    namespace "com.encorereactsdk"
+    compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+    defaultConfig {
+        minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+        targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    lint {
+        disable "GradleCompatible"
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+def minKotlinVersion = project.properties["EncoreReactSDK_kotlinVersion"]
+def hostKotlinVersion = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : null
+def kotlin_version = hostKotlinVersion ?: minKotlinVersion
+
+if (hostKotlinVersion != null) {
+    def hostParts = hostKotlinVersion.tokenize('.').collect { it.toInteger() }
+    def minParts = minKotlinVersion.tokenize('.').collect { it.toInteger() }
+    def hostVer = hostParts[0] * 10000 + hostParts[1] * 100 + hostParts[2]
+    def minVer = minParts[0] * 10000 + minParts[1] * 100 + minParts[2]
+    if (hostVer < minVer) {
+        throw new GradleException(
+            "@encorekit/react-native requires Kotlin >= ${minKotlinVersion}, " +
+            "but your project uses ${hostKotlinVersion}. " +
+            "Update kotlinVersion in your root build.gradle."
+        )
+    }
+}
+
+dependencies {
+    // Host app provides these
+    compileOnly "com.facebook.react:react-android:+"
+    compileOnly "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    // Bridge uses coroutines for async calls to native SDK
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
+
+    // Encore native Android SDK — we own this version
+    implementation "com.encorekit:encore:${encoreAndroidVersion}"
+}
+

package/android/gradle.properties

@@ -0,0 +1,11 @@
+# Android SDK versions
+EncoreReactSDK_compileSdkVersion=34
+EncoreReactSDK_minSdkVersion=21
+EncoreReactSDK_targetSdkVersion=34
+
+# Kotlin version
+EncoreReactSDK_kotlinVersion=1.9.24
+
+# AndroidX
+android.useAndroidX=true
+

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    
+    <!-- Required for opening URLs -->
+    <uses-permission android:name="android.permission.INTERNET" />
+    
+</manifest>
+
+

package/android/src/main/java/com/encorereactsdk/EncoreReactSDKModule.kt

@@ -0,0 +1,216 @@
+// EncoreReactSDKModule.kt
+// Android bridge — delegates all calls to the native encore-android-sdk.
+
+package com.encorereactsdk
+
+import com.encorekit.encore.Encore
+import com.encorekit.encore.core.canonical.user.UserAttributes
+import com.encorekit.encore.core.infrastructure.logging.LogLevel
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+@ReactModule(name = EncoreReactSDKModule.NAME)
+class EncoreReactSDKModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+    @Volatile private var currentDeferred: CompletableDeferred<Boolean>? = null
+
+    companion object {
+        const val NAME = "EncoreReactSDK"
+    }
+
+    override fun getName(): String = NAME
+
+    // -- Configuration --
+
+    @ReactMethod
+    fun configure(apiKey: String, options: ReadableMap, promise: Promise) {
+        val logLevel = when (options.getStringOrNull("logLevel")) {
+            "error" -> LogLevel.ERROR
+            "warn" -> LogLevel.WARN
+            "info" -> LogLevel.INFO
+            "debug" -> LogLevel.DEBUG
+            else -> LogLevel.NONE
+        }
+        Encore.shared.configure(reactApplicationContext, apiKey = apiKey, logLevel = logLevel)
+        promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+    }
+
+    // -- User Identity --
+
+    @ReactMethod
+    fun identify(userId: String, attributes: ReadableMap?, promise: Promise) {
+        Encore.shared.identify(userId = userId, attributes = parseAttributes(attributes))
+        promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+    }
+
+    @ReactMethod
+    fun setUserAttributes(attributes: ReadableMap, promise: Promise) {
+        parseAttributes(attributes)?.let { Encore.shared.setUserAttributes(it) }
+        promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+    }
+
+    @ReactMethod
+    fun reset(promise: Promise) {
+        Encore.shared.reset()
+        promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+    }
+
+    // -- Claim Control --
+
+    @ReactMethod
+    fun setClaimEnabled(enabled: Boolean, promise: Promise) {
+        Encore.shared.placements.isClaimEnabled = enabled
+        promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+    }
+
+    // -- Offers --
+
+    @ReactMethod
+    fun show(placementId: String, promise: Promise) {
+        val activity = currentActivity
+        if (activity == null) {
+            promise.reject("NO_ACTIVITY", "No current activity available")
+            return
+        }
+
+        scope.launch {
+            try {
+                val result = Encore.shared.placement(placementId).show(activity)
+                val map = Arguments.createMap()
+                when (result) {
+                    is com.encorekit.encore.features.offers.PresentationResult.Completed -> {
+                        map.putString("status", "completed")
+                        map.putString("offerId", result.offerId)
+                        map.putString("campaignId", result.campaignId)
+                    }
+                    is com.encorekit.encore.features.offers.PresentationResult.Dismissed -> {
+                        map.putString("status", "dismissed")
+                        map.putString("reason", result.reason.value)
+                    }
+                    is com.encorekit.encore.features.offers.PresentationResult.NoOffers -> {
+                        map.putString("status", "no_offers")
+                    }
+                }
+                promise.resolve(map)
+            } catch (e: Exception) {
+                promise.reject("SHOW_FAILED", e.message, e)
+            }
+        }
+    }
+
+    // -- Callbacks --
+
+    @ReactMethod
+    fun registerCallbacks(promise: Promise) {
+        Encore.shared
+            .onPurchaseRequest { request ->
+                // Fail stale deferred so the previous purchase flow resolves
+                currentDeferred?.complete(false)
+
+                val deferred = CompletableDeferred<Boolean>()
+                currentDeferred = deferred
+
+                try {
+                    sendEvent("onPurchaseRequest", Arguments.createMap().apply {
+                        putString("productId", request.productId)
+                        putString("placementId", request.placementId)
+                        putString("promoOfferId", request.promoOfferId)
+                    })
+                } catch (_: Exception) {
+                    // sendEvent can throw during context teardown — safe to ignore
+                }
+
+                val success = deferred.await()
+                currentDeferred = null
+
+                if (!success) {
+                    throw Exception("Purchase failed by JS handler")
+                }
+            }
+            .onPurchaseComplete { result, productId ->
+                sendEvent("onPurchaseComplete", Arguments.createMap().apply {
+                    putString("productId", productId)
+                    putString("purchaseToken", result.purchaseToken)
+                    putString("orderId", result.orderId)
+                })
+            }
+            .onPassthrough { placementId ->
+                sendEvent("onPassthrough", Arguments.createMap().apply {
+                    putString("placementId", placementId)
+                })
+            }
+
+        promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+    }
+
+    @ReactMethod
+    fun completePurchaseRequest(success: Boolean, promise: Promise) {
+        val deferred = currentDeferred
+        if (deferred != null) {
+            deferred.complete(success)
+            promise.resolve(Arguments.createMap().apply { putBoolean("success", true) })
+        } else {
+            promise.resolve(Arguments.createMap().apply {
+                putBoolean("success", false)
+                putString("error", "No pending purchase request")
+            })
+        }
+    }
+
+    // -- Helpers --
+
+    private fun sendEvent(eventName: String, params: WritableMap) {
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+
+    private fun parseAttributes(map: ReadableMap?): UserAttributes? {
+        map ?: return null
+        return UserAttributes(
+            email = map.getStringOrNull("email"),
+            firstName = map.getStringOrNull("firstName"),
+            lastName = map.getStringOrNull("lastName"),
+            phoneNumber = map.getStringOrNull("phoneNumber"),
+            postalCode = map.getStringOrNull("postalCode"),
+            city = map.getStringOrNull("city"),
+            state = map.getStringOrNull("state"),
+            countryCode = map.getStringOrNull("countryCode"),
+            latitude = map.getStringOrNull("latitude"),
+            longitude = map.getStringOrNull("longitude"),
+            dateOfBirth = map.getStringOrNull("dateOfBirth"),
+            gender = map.getStringOrNull("gender"),
+            language = map.getStringOrNull("language"),
+            subscriptionTier = map.getStringOrNull("subscriptionTier"),
+            monthsSubscribed = map.getStringOrNull("monthsSubscribed"),
+            billingCycle = map.getStringOrNull("billingCycle"),
+            lastPaymentAmount = map.getStringOrNull("lastPaymentAmount"),
+            lastActiveDate = map.getStringOrNull("lastActiveDate"),
+            totalSessions = map.getStringOrNull("totalSessions"),
+            custom = map.getCustomMap(),
+        )
+    }
+
+    private fun ReadableMap.getStringOrNull(key: String): String? =
+        if (hasKey(key)) getString(key) else null
+
+    private fun ReadableMap.getCustomMap(): Map<String, String> {
+        if (!hasKey("custom")) return emptyMap()
+        val customMap = getMap("custom") ?: return emptyMap()
+        val result = mutableMapOf<String, String>()
+        val iterator = customMap.keySetIterator()
+        while (iterator.hasNextKey()) {
+            val key = iterator.nextKey()
+            customMap.getString(key)?.let { result[key] = it }
+        }
+        return result
+    }
+}

package/android/src/main/java/com/encorereactsdk/EncoreReactSDKPackage.kt

@@ -0,0 +1,22 @@
+// EncoreReactSDKPackage.kt
+// React Native Package for Android
+
+package com.encorereactsdk
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class EncoreReactSDKPackage : ReactPackage {
+    @Deprecated("Deprecated in React Native")
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(EncoreReactSDKModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}
+
+

package/encore-react-sdk.podspec

@@ -0,0 +1,24 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "encore-react-sdk"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "15.0" }
+  s.source       = { :git => "https://github.com/EncoreKit/react-native-sdk.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+
+  ios_version = package["sdkVersions"]["ios"]["EncoreKit"]
+  s.dependency "React-Core"
+  s.dependency "EncoreKit", ios_version
+
+  s.swift_version = "5.9"
+  s.frameworks = "SafariServices", "UIKit"
+end

package/ios/EncoreReactSDK-Bridging-Header.h

@@ -0,0 +1,7 @@
+// EncoreReactSDK-Bridging-Header.h
+// Bridging header for Swift/Objective-C interoperability
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+

package/ios/EncoreReactSDK.m

@@ -0,0 +1,42 @@
+// EncoreReactSDK.m
+// Objective-C bridge declarations for React Native.
+// Each method here corresponds to a Swift method in EncoreReactSDK.swift.
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(EncoreReactSDK, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(configure:(NSString *)apiKey
+                  options:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(identify:(NSString *)userId
+                  attributes:(NSDictionary *)attributes
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setUserAttributes:(NSDictionary *)attributes
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(reset:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setClaimEnabled:(BOOL)enabled
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(show:(NSString *)placementId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(registerCallbacks:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(completePurchaseRequest:(BOOL)success
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end