@kontextso/sdk-react-native 3.0.7-rc.3 → 4.0.0-rc.1

package/src/Preload.ts

@@ -0,0 +1,150 @@
+import type { Message } from '@kontextso/sdk-common'
+import type{ Session } from './Session'
+import { fetchWithRetry } from './utils/request'
+
+type Bid = {
+  bidId: string
+  code: string
+}
+
+interface PreloadResponse {
+  bids?: Bid[]
+  sessionId?: string
+  skipCode?: string
+  skip?: boolean
+
+  // Error state
+  error?: string
+  errCode?: string
+  permanent?: boolean
+}
+
+export class Preload  {
+  public readonly session: Session
+  
+  private messages: Message[] = []
+  private abortController: AbortController
+  private running = false
+  private bid: Bid | null = null
+  
+  constructor(session: Session, messages: Message[]) {
+    this.session = session
+    this.abortController = new AbortController()
+    this.setMessages(messages)
+  }
+
+  private setMessages (messages: Message[]) {
+    this.messages = messages
+  }
+
+  hasBid () {
+    return this.bid !== null
+  }
+
+  getBid () {
+    return this.bid
+  }
+
+  private setBid (bid: Bid) {
+    this.bid = bid
+  }
+
+  cancel () {
+    this.abortController.abort()
+    this.running = false
+  }
+
+  isRunning () {
+    return this.running
+  }
+
+  /*
+  private async getDevice () {
+    try {
+      return await getDevice()
+    } catch (error) {
+      this.session.logger.error('Error getting device:', error)
+      return {} as DeviceConfig
+    }
+  }
+  */
+
+  private async getPreloadBody () {
+    const config = this.session.config
+    const preloadBody: Record<string, any> = {
+      messages: this.messages,
+      sessionId: this.session.getSessionId(),
+      publisherToken: config.publisherToken,
+      userId: config.userId,
+      userEmail: config.userEmail,
+      conversationId: config.conversationId,
+      character: config.character,
+      enabledPlacementCodes: [config.placementCode],
+      variantId: config.variantId,
+      regulatory: config.regulatory,
+      sdk: this.session.sdk,
+    }
+    return preloadBody
+  }
+
+  private canRequestAd () {
+    if (this.session.isSessionDisabled()) {
+      return {
+        status: 'error',
+        message: 'Session is disabled',
+      }
+    }
+    if (!this.messages.length) {
+      return {
+        status: 'error',
+        message: 'No messages',
+      }
+    }
+    return null
+  }
+
+  async requestAd () {
+    this.running = true
+    const cannotRequestAdReason = this.canRequestAd()
+    if (cannotRequestAdReason) {
+      return cannotRequestAdReason
+    }
+
+    const config = this.session.config
+    const preloadBody = await this.getPreloadBody()
+
+    try {
+      const response = await fetchWithRetry(`${config.adServerUrl}/preload`, {
+        method: 'POST',
+        body: JSON.stringify(preloadBody),
+        headers: {
+          'Kontextso-Is-Disabled': '0',
+          'Kontextso-Publisher-Token': config.publisherToken,
+        },
+        timeout: 16000,
+        abortController: this.abortController,
+      })
+
+      const jsonResponse = await response.json() as PreloadResponse
+
+      const bid = jsonResponse.bids?.[0] ?? null
+      if (jsonResponse.sessionId) {
+        this.session.setSessionId(jsonResponse.sessionId)
+      }
+      if (bid) {
+        this.setBid(bid)
+      }
+      this.session.updateBids()
+      return {
+        status: 'success',
+      }
+    } catch (error) {
+      this.session.logger.error('Error requesting ad:', error)
+      return {
+        status: 'error',
+      }
+    } finally {
+      this.running = false
+    }
+  }
+}

package/src/Session.ts

@@ -0,0 +1,104 @@
+import type { Message } from '@kontextso/sdk-common'
+import type { Configuration } from './Configuration'
+import { Logger } from './Logger'
+import { Preload } from './Preload'
+import type { SDKConfig } from './utils/sdk'
+
+export class Session {
+  public readonly config: Configuration
+  public readonly logger: Logger
+  public readonly sdk: SDKConfig
+
+  private sessionId: string | null = null
+  private sessionDisabled = false
+  private messages: Message[] = []
+  private bids: {
+    bidId: string
+    messageId: string
+  }[] = []
+  private onUpdateBidsCallback: (() => void) | null = null
+
+
+  // only one preload instance is allowed at a time
+  private preloadInstance: Preload | null = null
+
+  constructor(config: Configuration, { sdk }: { sdk: SDKConfig }) {
+    this.config = config
+    this.logger = new Logger()
+    this.sdk = sdk
+  }
+
+  setOnUpdateBids (callback: () => void) {
+    this.onUpdateBidsCallback = callback
+  }
+
+  isSessionDisabled () {
+    return this.sessionDisabled
+  }
+
+  setSessionDisabled (disabled: boolean) {
+    this.sessionDisabled = disabled
+  }
+
+  getSessionId () {
+    return this.sessionId
+  }
+
+  setSessionId (sessionId: string) {
+    this.logger.info('Session ID set:', sessionId)
+    this.sessionId = sessionId
+  }
+
+  addMessage (message: Message) {
+    this.messages.push(message)
+    this.updateBids()
+  }
+
+  getMessages () {
+    return this.messages
+  }
+
+  public updateBids() {
+    if (!this.preloadInstance?.hasBid()) {
+      return
+    }
+    const bid = this.preloadInstance.getBid()
+    if (!bid) {
+
+      return
+    }
+    const lastMessage = this.messages[this.messages.length - 1]
+    if (!lastMessage || lastMessage.role !== 'assistant') {
+      return
+    }
+    const assignedBid = this.bids.find((b) => {
+      if (b.bidId === bid?.bidId) {
+        return true
+      }
+      if (b.messageId === lastMessage.id) {
+        return true
+      }
+      return false
+    })
+    if (assignedBid) {
+      return
+    }
+    this.bids.push({
+      bidId: bid.bidId,
+      messageId: lastMessage.id,
+    })
+    this.onUpdateBidsCallback?.()
+  }
+
+  preload () {
+    if (this.preloadInstance?.isRunning()) {
+      this.preloadInstance.cancel()
+    }
+    this.preloadInstance = new Preload(this, [...this.messages])
+    return this.preloadInstance
+  }
+
+  getLastBid () {
+    return this.bids[this.bids.length - 1]
+  }
+}

package/src/index.ts

@@ -1,5 +1,3 @@
-import InlineAd from './formats/InlineAd'
+export { InlineAd } from './InlineAd'
+export { KontextAds } from './KontextAds'
 
-export * from './context/AdsProvider'
-
-export { InlineAd }

package/src/utils/request.ts

@@ -0,0 +1,73 @@
+/**
+ * Request function with retry and exponential backoff
+ */
+export async function fetchWithRetry(
+  url: string,
+  options: RequestInit & {
+    retry?: {
+      maxRetries?: number
+      baseDelay?: number
+      backoffFactor?: number
+    }
+    timeout?: number
+    abortController?: AbortController
+  } = {}
+): Promise<Response> {
+  const { retry = {}, timeout, abortController: abortControllerOption, ...fetchOptions } = options
+
+  const maxRetries = retry.maxRetries ?? 3
+  const baseDelay = retry.baseDelay ?? 1000
+  const backoffFactor = retry.backoffFactor ?? 2
+
+  const abortController = abortControllerOption || new AbortController()
+  fetchOptions.signal = abortController.signal
+
+  let timeoutId: ReturnType<typeof setTimeout> | null = null
+  if (timeout) {
+    timeoutId = setTimeout(() => abortController.abort('timeout'), timeout)
+  }
+
+  let lastError: Error | null = null
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(url, fetchOptions)
+
+      // Throw only re-tryable errors, otherwise return the response to let the caller handle it
+      if (response.status >= 500 || response.status === 429) {
+        const error = new Error(`HTTP ${response.status}: ${response.statusText}`)
+        ;(error as any).status = response.status
+        throw error
+      }
+
+      return response
+    } catch (error) {
+      if (abortController.signal.aborted) {
+        throw new Error(`Fetch aborted: ${abortController.signal.reason}`)
+      }
+
+      lastError = error instanceof Error ? error : new Error('Unknown error')
+
+      // Retry on network errors and 5xx status codes
+      const shouldRetry =
+        error instanceof TypeError || // Network error
+        (error as any).status >= 500 || // Server error
+        (error as any).status === 429 // Rate limited
+
+      // Don't retry on last attempt or if error shouldn't be retried
+      if (attempt === maxRetries || !shouldRetry) {
+        break
+      }
+
+      // Wait before retry (exponential backoff)
+      const delay = baseDelay * backoffFactor ** attempt
+      await new Promise((resolve) => setTimeout(resolve, delay))
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId)
+      }
+    }
+  }
+
+  throw lastError
+}

package/src/utils/sdk.ts

@@ -0,0 +1,16 @@
+
+import type { SDK } from '@kontextso/sdk-common'
+import { Platform } from 'react-native'
+import { version } from '../../package.json'
+
+export interface SDKConfig {
+  name: Exclude<SDK, 'sdk'>
+  platform: 'ios' | 'android' | 'web'
+  version: string
+}
+
+export const getSdk = async (): Promise<SDKConfig> => ({
+  name: 'sdk-react-native',
+  platform: Platform.OS === 'ios' ? 'ios' : 'android',
+  version,
+})

package/android/build.gradle

@@ -1,88 +0,0 @@
-buildscript {
-  ext.getExtOrDefault = {name ->
-    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['RNKontext_' + 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')}"
-  }
-}
-
-
-apply plugin: "com.android.library"
-apply plugin: "kotlin-android"
-
-apply plugin: "com.facebook.react"
-
-def isNewArchitectureEnabled() {
-  return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
-}
-
-def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["RNKontext_" + name]).toInteger()
-}
-
-android {
-  namespace "so.kontext.react"
-
-  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
-
-  defaultConfig {
-    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
-    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-    // Expose the new-arch flag to runtime and build-time Kotlin/Java code
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
-  }
-
-  buildFeatures {
-    buildConfig 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"
-      ]
-      if (isNewArchitectureEnabled()) {
-        java.srcDirs += ['src/newarch/java']
-      } else {
-        java.srcDirs += ['src/oldarch/java']
-      }
-    }
-  }
-}
-
-repositories {
-  mavenCentral()
-  google()
-}
-
-def kotlin_version = getExtOrDefault("kotlinVersion")
-
-dependencies {
-  implementation "com.facebook.react:react-android"
-  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-}

package/android/gradle.properties

@@ -1,5 +0,0 @@
-RNKontext_kotlinVersion=2.0.21
-RNKontext_minSdkVersion=24
-RNKontext_targetSdkVersion=34
-RNKontext_compileSdkVersion=35
-RNKontext_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/java/so/kontext/react/RNKontextModuleImpl.kt

@@ -1,21 +0,0 @@
-package so.kontext.react
-
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import android.content.Context
-import android.media.AudioManager
-
-class RNKontextModuleImpl(private val reactContext: ReactApplicationContext) {
-  fun isSoundOn(promise: Promise?) {
-    val audioManager = reactContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-    val current = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC)
-    val max = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC)
-    val volume = if (max > 0) current.toFloat() / max.toFloat() else 0f
-
-    promise?.resolve(volume > MINIMAL_VOLUME_THRESHOLD)
-  }
-
-  companion object {
-    private const val MINIMAL_VOLUME_THRESHOLD = 0.0f
-  }
-}

package/android/src/newarch/java/so/kontext/react/RNKontextModule.kt

@@ -1,22 +0,0 @@
-package so.kontext.react
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.bridge.Promise
-
-@ReactModule(name = RNKontextModule.NAME)
-class RNKontextModule(reactContext: ReactApplicationContext) :
-  NativeRNKontextSpec(reactContext) {
-
-  private val impl = RNKontextModuleImpl(reactContext)
-
-  override fun getName(): String = NAME
-
-  override fun isSoundOn(promise: Promise?) {
-    impl.isSoundOn(promise)
-  }
-
-  companion object {
-    const val NAME = "RNKontext"
-  }
-}

package/android/src/newarch/java/so/kontext/react/RNKontextPackage.kt

@@ -1,32 +0,0 @@
-package so.kontext.react
-
-import com.facebook.react.BaseReactPackage
-import com.facebook.react.bridge.NativeModule
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.module.model.ReactModuleInfo
-import com.facebook.react.module.model.ReactModuleInfoProvider
-
-class RNKontextPackage : BaseReactPackage() {
-  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-    return if (name == RNKontextModule.NAME) {
-      RNKontextModule(reactContext)
-    } else {
-      null
-    }
-  }
-
-  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
-    return ReactModuleInfoProvider {
-      mapOf(
-        RNKontextModule.NAME to ReactModuleInfo(
-          RNKontextModule.NAME,
-          RNKontextModule.NAME,
-          false,  // canOverrideExistingModule
-          false,  // needsEagerInit
-          false,  // isCxxModule
-          true    // isTurboModule
-        )
-      )
-    }
-  }
-}

package/android/src/oldarch/java/so/kontext/react/RNKontextModule.kt

@@ -1,25 +0,0 @@
-package so.kontext.react
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.Promise
-import android.content.Context
-import android.media.AudioManager
-
-class RNKontextModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
-
-  private val impl = RNKontextModuleImpl(reactContext)
-
-  override fun getName(): String = NAME
-
-  @ReactMethod
-  fun isSoundOn(promise: Promise?) {
-    impl.isSoundOn(promise)
-  }
-
-  companion object {
-    const val NAME = "RNKontext"
-  }
-}

package/android/src/oldarch/java/so/kontext/react/RNKontextPacakge.kt

@@ -1,16 +0,0 @@
-package so.kontext.react
-
-import com.facebook.react.ReactPackage
-import com.facebook.react.bridge.NativeModule
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
-
-class RNKontextPackage : ReactPackage {
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf(RNKontextModule(reactContext))
-  }
-
-  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return emptyList()
-  }
-}

package/ios/KontextSDK.swift

@@ -1,26 +0,0 @@
-import AVFoundation
-
-@objc(KontextSDK)
-public class KontextSDK: NSObject {
-    private static let MINIMAL_VOLUME_THRESHOLD: Float = 0.0
-
-    @objc
-    public static func isSoundOn() -> NSNumber? {
-        let session = AVAudioSession.sharedInstance()
-
-        do {
-            try session.setCategory(
-                .ambient,
-                mode: .default,
-                options: [.mixWithOthers]
-            )
-            try session.setActive(true)
-
-            return NSNumber(
-                value: session.outputVolume > MINIMAL_VOLUME_THRESHOLD
-            )
-        } catch {
-            return nil
-        }
-    }
-}

package/ios/RNKontext.h

@@ -1,13 +0,0 @@
-#import "RNKontext-Swift.h"
-
-#ifdef RCT_NEW_ARCH_ENABLED
-#import <RNKontextSpec/RNKontextSpec.h>
-
-@interface RNKontext: NSObject <NativeRNKontextSpec>
-#else
-#import <React/RCTBridgeModule.h>
-
-@interface RNKontext: NSObject <RCTBridgeModule>
-#endif
-
-@end

package/ios/RNKontext.mm

@@ -1,36 +0,0 @@
-#import "RNKontext.h"
-
-@implementation RNKontext
-
-RCT_EXPORT_MODULE()
-
-#ifdef RCT_NEW_ARCH_ENABLED
-- (void)isSoundOn:(RCTPromiseResolveBlock)resolve
-           reject:(RCTPromiseRejectBlock)reject {
-    NSNumber *isSoundOn = [KontextSDK isSoundOn];
-
-    if (isSoundOn == nil) {
-        reject(@"soundon_error", @"Failed to read output volume", nil);
-    } else {
-        resolve(isSoundOn);
-    }
-}
-
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
-    (const facebook::react::ObjCTurboModule::InitParams &)params {
-    return std::make_shared<facebook::react::NativeRNKontextSpecJSI>(params);
-}
-#else
-RCT_EXPORT_METHOD(isSoundOn : (RCTPromiseResolveBlock)
-                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
-    NSNumber *isSoundOn = [KontextSDK isSoundOn];
-
-    if (isSoundOn == nil) {
-        reject(@"soundon_error", @"Failed to read output volume", nil);
-    } else {
-        resolve(isSoundOn);
-    }
-}
-#endif
-
-@end

package/src/__tests__/util.test.ts

@@ -1,9 +0,0 @@
-import { describe, expect, test } from 'vitest'
-
-describe('utils', () => {
-  describe('test', () => {
-    test('test', () => {
-      expect(1).toBe(1)
-    })
-  })
-})