@kontextso/sdk-react-native 3.0.7-rc.2 → 4.0.0-rc.0

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/device.ts

@@ -0,0 +1,89 @@
+
+import { detectDeviceType, detectOS, parseUserAgent } from '@kontextso/utils/user-agent'
+
+interface DeviceHardware {
+  type: 'handset' | 'tablet' | 'desktop' | 'tv' | 'other'
+  bootTime?: number
+  brand?: string
+  model?: string
+  sdCardAvailable?: boolean
+}
+
+interface OperatingSystem {
+  name: string
+  version: string
+  locale: string
+  timezone: string
+}
+
+interface ScreenInfo {
+  darkMode: boolean
+  dpr: number
+  height: number
+  width: number
+  orientation?: 'portrait' | 'landscape'
+}
+
+interface AudioInfo {
+  volume?: number
+  muted?: boolean
+  outputPluggedIn?: boolean
+  outputType?: Array<'wired' | 'hdmi' | 'bluetooth' | 'usb' | 'other'>
+}
+
+interface NetworkInfo {
+  carrier?: string
+  detail?: string
+  type?: 'wifi' | 'cellular' | 'ethernet' | 'other'
+  userAgent?: string
+}
+
+interface PowerInfo {
+  batteryLevel?: number
+  batteryState?: 'charging' | 'full' | 'unplugged' | 'unknown'
+  lowPowerMode?: boolean
+}
+
+export interface DeviceConfig {
+  hardware: DeviceHardware
+  os: OperatingSystem
+  screen: ScreenInfo
+  audio?: AudioInfo
+  network?: NetworkInfo
+  power?: PowerInfo
+}
+
+export const getDevice = async (): Promise<DeviceConfig> => {
+  const userAgent = navigator.userAgent
+  const parsedUserAgent = parseUserAgent(userAgent)
+  const parsedDevice = parsedUserAgent?.getDevice()
+  const parsedOS = parsedUserAgent?.getOS()
+  // @ts-expect-error Not in types
+  const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection
+
+  return {
+    network: {
+      userAgent,
+      detail: connection?.effectiveType,
+      type: connection?.type,
+    },
+    screen: {
+      width: screen.width,
+      height: screen.height,
+      dpr: window.devicePixelRatio || 1,
+      orientation: screen.orientation?.type?.includes('portrait') ? 'portrait' : 'landscape',
+      darkMode: window.matchMedia?.('(prefers-color-scheme: dark)').matches,
+    },
+    hardware: {
+      type: detectDeviceType(parsedUserAgent),
+      brand: parsedDevice?.vendor,
+      model: parsedDevice?.model,
+    },
+    os: {
+      name: detectOS(parsedUserAgent),
+      version: parsedOS?.version || '',
+      locale: navigator.language || 'en-US',
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    },
+  }
+}

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 { Platform } from '@kontextso/utils/user-agent'
+import type { SDK } from '@kontextso/sdk-common'
+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-js',
+  platform: Platform.Web,
+  version,
+})

package/src/utils/validation.ts

@@ -0,0 +1,59 @@
+import type { FetchAdParams } from "./interface"
+
+const DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/
+
+export const validateFetchAdSettings = (settings: FetchAdParams) => {
+  if (!settings.adServerUrl) {
+    throw new Error('Server URL is required.')
+  }
+  if (!settings.publisherToken) {
+    throw new Error('Publisher token is required.')
+  }
+  if (!settings.conversationId) {
+    throw new Error('Conversation ID is required.')
+  }
+  if (typeof settings.conversationId !== 'string') {
+    throw new Error('Conversation ID must be a string.')
+  }
+  if (!settings.userId) {
+    throw new Error('User ID is required.')
+  }
+  if (typeof settings.userId !== 'string') {
+    throw new Error('User ID must be a string.')
+  }
+  if (!settings.enabledPlacementCodes || !Array.isArray(settings.enabledPlacementCodes) || settings.enabledPlacementCodes.length === 0) {
+    throw new Error('Placement code is required.')
+  }
+  if (!settings.messages || !Array.isArray(settings.messages) || settings.messages.length === 0) {
+    throw new Error('Messages are required.')
+  }
+  settings.messages.forEach((message: any) => {
+    if (!message.id) {
+      throw new Error('Message ID is required.')
+    }
+    if (typeof message.id !== 'string') {
+      throw new Error('Message ID must be a string.')
+    }
+    if (!message.content) {
+      throw new Error('Message content is required.')
+    }
+    if (!message.createdAt) {
+      throw new Error('Message createdAt is required.')
+    }
+    if (typeof message.createdAt !== 'string' && !(message.createdAt instanceof Date)) {
+      throw new Error('Message createdAt must be string or Date object.')
+    }
+    if (typeof message.createdAt === 'string' && !DATE_REGEX.test(message.createdAt)) {
+      throw new Error('Message createdAt must be a valid ISO 8601 date string.')
+    }
+    if (message.createdAt instanceof Date && Number.isNaN(message.createdAt.getTime())) {
+      throw new Error('Message createdAt must be a valid Date object.')
+    }
+    if (!message.role) {
+      throw new Error('Message role is required.')
+    }
+    if (message.role !== 'assistant' && message.role !== 'user') {
+      throw new Error('Message role must be either "assistant" or "user".')
+    }
+  })
+}

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