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

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,21 +15,13 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AdsProvider: () => AdsProvider,
-  InlineAd: () => InlineAd_default
+  InlineAd: () => InlineAd,
+  KontextAds: () => KontextAds
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -54,671 +44,534 @@ function handleIframeMessage(handler, opts) {
   };
 }
 
-// src/formats/Format.tsx
-var import_sdk_react = require("@kontextso/sdk-react");
-var import_react2 = require("react");
-var import_react_native = require("react-native");
-
-// src/frame-webview.tsx
+// src/InlineAd.tsx
 var import_react = require("react");
 var import_react_native_webview = require("react-native-webview");
 var import_jsx_runtime = require("react/jsx-runtime");
-var FrameWebView = (0, import_react.forwardRef)(
-  ({ iframeUrl, onMessage, style, onError, onLoad }, forwardedRef) => {
-    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-      import_react_native_webview.WebView,
-      {
-        ref: forwardedRef,
-        source: {
-          uri: iframeUrl
-        },
-        onMessage,
-        style,
-        allowsInlineMediaPlayback: true,
-        mediaPlaybackRequiresUserAction: false,
-        javaScriptEnabled: true,
-        domStorageEnabled: true,
-        allowsFullscreenVideo: false,
-        injectedJavaScript: `
-          window.addEventListener("message", function(event) {
-            if (window.ReactNativeWebView && event.data) {
-              // ReactNativeWebView.postMessage only supports string data
-              window.ReactNativeWebView.postMessage(JSON.stringify(event.data));
-            }
-          }, false);
-      `,
-        onError,
-        onLoad
-      }
-    );
-  }
-);
-var frame_webview_default = FrameWebView;
-
-// src/formats/Format.tsx
-var import_jsx_runtime2 = require("react/jsx-runtime");
-var sendMessage = (webViewRef, type, code, data) => {
-  const message = makeIframeMessage(type, {
-    data,
-    code
+var getIframeUrl = (bidId, messageId, adServerUrl) => {
+  const params = new URLSearchParams({
+    code: "inlineAd",
+    messageId,
+    sdk: "sdk-react-native"
   });
-  webViewRef.current?.injectJavaScript(`
-    window.dispatchEvent(new MessageEvent('message', {
-      data: ${JSON.stringify(message)}
-    }));
-  `);
+  return `${adServerUrl}/api/frame/${bidId}?${params}`;
 };
-var getCachedContent = (context, bidId) => {
-  if (!bidId) {
-    return null;
-  }
-  return context?.cachedContentRef?.current?.get(bidId) ?? null;
-};
-var Format = ({ code, messageId, wrapper, onEvent, ...otherParams }) => {
-  const context = (0, import_react2.useContext)(import_sdk_react.AdsContext);
-  const bid = (0, import_sdk_react.useBid)({ code, messageId });
-  const [height, setHeight] = (0, import_react2.useState)(0);
-  const cachedContent = getCachedContent(context, bid?.bidId);
-  const iframeUrl = (0, import_sdk_react.useIframeUrl)(bid, code, messageId, "sdk-react-native", otherParams.theme, cachedContent);
-  const modalUrl = iframeUrl.replace("/api/frame/", "/api/modal/");
-  const [showIframe, setShowIframe] = (0, import_react2.useState)(false);
-  const [iframeLoaded, setIframeLoaded] = (0, import_react2.useState)(false);
-  const [modalOpen, setModalOpen] = (0, import_react2.useState)(false);
-  const [modalShown, setModalShown] = (0, import_react2.useState)(false);
-  const [modalLoaded, setModalLoaded] = (0, import_react2.useState)(false);
-  const [containerStyles, setContainerStyles] = (0, import_react2.useState)({});
-  const [iframeStyles, setIframeStyles] = (0, import_react2.useState)({});
-  const containerRef = (0, import_react2.useRef)(null);
-  const webViewRef = (0, import_react2.useRef)(null);
-  const modalWebViewRef = (0, import_react2.useRef)(null);
-  const modalInitTimeoutRef = (0, import_react2.useRef)(null);
-  const isModalInitRef = (0, import_react2.useRef)(false);
-  const { height: windowHeight, width: windowWidth } = (0, import_react_native.useWindowDimensions)();
-  const keyboardHeightRef = (0, import_react2.useRef)(0);
-  const isAdViewVisible = showIframe && iframeLoaded;
-  const reset = () => {
-    setHeight(0);
-    setShowIframe(false);
-    setContainerStyles({});
-    setIframeStyles({});
-    setIframeLoaded(false);
-    resetModal();
-    context?.resetAll();
-    context?.captureError(new Error("Processing iframe error"));
-  };
-  const resetModal = () => {
-    debugModal("Format:resetModal", {
-      params: {
-        messageId,
-        code,
-        otherParams
-      }
-    });
-    if (modalInitTimeoutRef.current) {
-      debugModal("Format:resetModalTimeout", {
-        params: {
-          messageId,
-          code,
-          otherParams
-        }
-      });
-      clearTimeout(modalInitTimeoutRef.current);
-      modalInitTimeoutRef.current = null;
+var InlineAd = ({ messageId, session, onDebugEvent }) => {
+  const [bidId, setBidId] = (0, import_react.useState)(null);
+  const webViewRef = (0, import_react.useRef)(null);
+  const postRef = (0, import_react.useRef)({});
+  const sendMessage = (webViewRef2, type, code, data) => {
+    if (postRef.current[messageId]) {
+      onDebugEvent("InlineAd: message already posted", { messageId, ref: postRef.current });
+      return;
     }
-    isModalInitRef.current = false;
-    setModalOpen(false);
-    setModalLoaded(false);
-    setModalShown(false);
-  };
-  const debug = (name, data = {}) => {
-    context?.onDebugEventInternal?.(name, {
-      code,
-      messageId,
-      otherParams,
-      bid,
-      iframeUrl,
-      iframeLoaded,
-      showIframe,
-      height,
-      containerStyles,
-      iframeStyles,
-      ...data
-    });
-  };
-  const debugModal = (name, data = {}) => {
-    context?.onDebugEventInternal?.(name, {
-      code,
-      messageId,
-      otherParams,
-      bid,
-      modalUrl,
-      modalOpen,
-      modalShown,
-      modalLoaded,
-      ...data
+    const message = makeIframeMessage(type, {
+      data,
+      code
     });
+    onDebugEvent("InlineAd: post message", { messageId, message });
+    webViewRef2.current?.injectJavaScript(`
+      window.dispatchEvent(new MessageEvent('message', {
+        data: ${JSON.stringify(message)}
+      }));
+    `);
+    postRef.current[messageId] = true;
   };
-  debug("Format:updateState", {
-    params: {
-      messageId,
-      code,
-      otherParams
+  const updateBid = (0, import_react.useCallback)(() => {
+    const bid = session.getLastBid();
+    if (!bid || bid.messageId !== messageId) {
+      setBidId(null);
+      onDebugEvent("InlineAd: no bid", { messageId, bid });
+      return;
     }
-  });
+    setBidId(bid.bidId);
+    onDebugEvent("InlineAd: update bid", { messageId, bid });
+  }, [session, messageId]);
+  (0, import_react.useEffect)(() => {
+    session.setOnUpdateBids(updateBid);
+    return () => {
+      session.setOnUpdateBids(void 0);
+      onDebugEvent("InlineAd: remove update bids callback", { messageId });
+    };
+  }, [session, updateBid]);
+  (0, import_react.useEffect)(() => {
+    updateBid();
+  }, [updateBid]);
+  if (!bidId) {
+    onDebugEvent("InlineAd: no bid id", { messageId, bidId });
+    return null;
+  }
+  const iframeUrl = getIframeUrl(bidId, messageId, session.config.adServerUrl);
+  if (!iframeUrl) {
+    onDebugEvent("InlineAd: no iframe url", { messageId, bidId });
+    return null;
+  }
   const onMessage = (event) => {
     try {
       const data = JSON.parse(event.nativeEvent.data);
-      debug("Format:iframeMessage", {
-        message: data,
-        params: { data, messageId, code, otherParams }
-      });
       const messageHandler = handleIframeMessage(
         (message) => {
+          onDebugEvent("InlineAd: message handler", { messageId, message, bidId });
           switch (message.type) {
             case "init-iframe":
-              setIframeLoaded(true);
-              debug("Format:iframePostMessage", {
-                params: {
-                  code,
-                  messages: context?.messages,
-                  sdk: "sdk-react-native",
-                  otherParams,
-                  messageId
-                }
-              });
-              sendMessage(webViewRef, "update-iframe", code, {
-                messages: context?.messages,
+              sendMessage(webViewRef, "update-iframe", "inlineAd", {
+                messages: session.getMessages(),
                 sdk: "sdk-react-native",
-                otherParams,
+                otherParams: {},
                 messageId
               });
               break;
             case "error-iframe":
-              reset();
-              break;
-            case "resize-iframe":
-              setHeight(message.data.height);
               break;
             case "click-iframe":
-              if (message.data.url) {
-                import_react_native.Linking.openURL(`${context?.adServerUrl}${message.data.url}`).catch(
-                  (err) => console.error("error opening url", err)
-                );
-              }
-              context?.onAdClickInternal(message.data);
               break;
             case "view-iframe":
-              context?.onAdViewInternal(message.data);
-              break;
-            case "ad-done-iframe":
-              if (bid?.bidId && message.data.cachedContent) {
-                context?.cachedContentRef?.current?.set(bid.bidId, message.data.cachedContent);
-              }
-              break;
-            case "show-iframe":
-              setShowIframe(true);
-              break;
-            case "hide-iframe":
-              setShowIframe(false);
-              break;
-            case "set-styles-iframe":
-              setContainerStyles(message.data.containerStyles);
-              setIframeStyles(message.data.iframeStyles);
-              break;
-            case "open-component-iframe":
-              setModalOpen(true);
-              modalInitTimeoutRef.current = setTimeout(() => {
-                if (!isModalInitRef.current) {
-                  resetModal();
-                }
-              }, message.data.timeout ?? 5e3);
-              break;
-            case "event-iframe":
-              onEvent?.(message.data);
-              context?.onAdEventInternal(message.data);
-              break;
-          }
-        },
-        {
-          code
-        }
-      );
-      messageHandler({ data });
-    } catch (e) {
-      debug("Format:iframeMessageError", {
-        params: { error: e, messageId, code, otherParams },
-        error: e
-      });
-      console.error("error parsing message from webview", e);
-      reset();
-    }
-  };
-  const onModalMessage = (event) => {
-    try {
-      const data = JSON.parse(event.nativeEvent.data);
-      debugModal("Format:modalIframeMessage", {
-        params: { data, messageId, code, otherParams },
-        message: data
-      });
-      const messageHandler = handleIframeMessage(
-        (message) => {
-          switch (message.type) {
-            case "close-component-iframe":
-              resetModal();
-              break;
-            case "init-component-iframe":
-              isModalInitRef.current = true;
-              if (modalInitTimeoutRef.current) {
-                clearTimeout(modalInitTimeoutRef.current);
-                modalInitTimeoutRef.current = null;
-              }
-              setModalShown(true);
-              break;
-            case "error-component-iframe":
-            case "error-iframe":
-              resetModal();
-              context?.captureError(new Error("Processing modal iframe error"));
-              break;
-            case "click-iframe":
-              if (message.data.url) {
-                import_react_native.Linking.openURL(`${context?.adServerUrl}${message.data.url}`).catch(
-                  (err) => console.error("error opening url", err)
-                );
-              }
-              context?.onAdClickInternal(message.data);
               break;
             case "event-iframe":
-              onEvent?.(message.data);
-              context?.onAdEventInternal(message.data);
               break;
           }
         },
         {
-          code,
-          component: "modal"
+          code: "inlineAd"
         }
       );
       messageHandler({ data });
     } catch (e) {
-      debugModal("Format:modalIframeMessageError", {
-        params: { error: e, messageId, code, otherParams },
-        error: e
-      });
       console.error("error parsing message from webview", e);
-      resetModal();
+      onDebugEvent("InlineAd: error parsing message from webview", { messageId, error: e });
     }
   };
-  const paramsString = (0, import_sdk_react.convertParamsToString)(otherParams);
-  (0, import_react2.useEffect)(() => {
-    if (!iframeLoaded || !context?.adServerUrl || !bid || !webViewRef.current) {
-      debug("Format:iframePostMessageNotLoaded", {
-        params: {
-          messageId,
-          iframeLoaded,
-          contextAdServerUrl: context?.adServerUrl,
-          bid,
-          code,
-          otherParams
-        }
-      });
-      return;
-    }
-    debug("Format:iframePostMessage", {
-      params: {
-        messageId,
-        otherParams,
-        code
-      }
-    });
-    sendMessage(webViewRef, "update-iframe", code, {
-      data: { otherParams },
-      code
-    });
-  }, [paramsString, iframeLoaded, context?.adServerUrl, bid, code]);
-  const checkIfInViewport = () => {
-    if (!containerRef.current) {
-      debug("Format:checkIfInViewportNoContainer", {
-        params: {
-          messageId,
-          code,
-          otherParams
-        }
-      });
-      return;
-    }
-    debug("Format:checkIfInViewportMeasure", {
-      params: {
-        windowWidth,
-        windowHeight,
-        messageId,
-        code,
-        otherParams
-      }
-    });
-    containerRef.current.measureInWindow((containerX, containerY, containerWidth, containerHeight) => {
-      sendMessage(webViewRef, "update-dimensions-iframe", code, {
-        windowWidth,
-        windowHeight,
-        containerWidth,
-        containerHeight,
-        containerX,
-        containerY,
-        keyboardHeight: keyboardHeightRef.current
-      });
-      debug("Format:checkIfInViewportMeasureSend", {
-        params: {
-          messageId,
-          code,
-          otherParams,
-          windowWidth,
-          windowHeight,
-          containerWidth,
-          containerHeight,
-          containerX,
-          containerY,
-          keyboardHeight: keyboardHeightRef.current
-        }
-      });
-    });
-  };
-  (0, import_react2.useEffect)(() => {
-    if (!isAdViewVisible) {
-      debug("Format:checkIfInViewportNotVisible", {
-        params: {
-          messageId,
-          code,
-          otherParams
-        }
-      });
-      return;
-    }
-    const interval = setInterval(() => {
-      checkIfInViewport();
-    }, 250);
-    return () => {
-      clearInterval(interval);
-      debug("Format:checkIfInViewportCleanup", {
-        params: {
-          messageId,
-          code,
-          otherParams
-        }
-      });
-    };
-  }, [isAdViewVisible]);
-  (0, import_react2.useEffect)(() => {
-    const showSubscription = import_react_native.Keyboard.addListener("keyboardDidShow", (e) => {
-      debug("Format:keyboardDidShow", {
-        params: {
-          keyboardHeight: e?.endCoordinates?.height ?? 0,
-          messageId,
-          code,
-          otherParams
-        }
-      });
-      keyboardHeightRef.current = e?.endCoordinates?.height ?? 0;
-    });
-    const hideSubscription = import_react_native.Keyboard.addListener("keyboardDidHide", () => {
-      debug("Format:keyboardDidHide", {
-        params: {
-          messageId,
-          code,
-          otherParams
-        }
-      });
-      keyboardHeightRef.current = 0;
-    });
-    return () => {
-      showSubscription.remove();
-      hideSubscription.remove();
-      keyboardHeightRef.current = 0;
-      debug("Format:keyboardEffectCleanup", {
-        params: {
-          messageId,
-          code,
-          otherParams
-        }
-      });
-    };
-  }, []);
-  if (!context || !bid || !iframeUrl) {
-    debug("Format:noContextOrBidOrIframeUrl", {
-      params: {
-        context,
-        bid,
-        iframeUrl,
-        messageId,
-        code,
-        otherParams
-      }
-    });
-    return null;
-  }
-  const inlineContent = /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-    frame_webview_default,
+  onDebugEvent("InlineAd: iframe url", { messageId, iframeUrl });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_react_native_webview.WebView,
     {
-      ref: webViewRef,
-      iframeUrl,
-      onMessage,
+      source: {
+        uri: iframeUrl
+      },
       style: {
-        height,
+        height: 300,
         width: "100%",
-        backgroundColor: "transparent",
-        borderWidth: 0,
-        ...iframeStyles
+        backgroundColor: "red"
       },
-      onError: () => {
-        debug("Format:iframeError", {
-          params: {
-            messageId,
-            code,
-            otherParams
+      ref: webViewRef,
+      onMessage,
+      allowsInlineMediaPlayback: true,
+      mediaPlaybackRequiresUserAction: false,
+      javaScriptEnabled: true,
+      domStorageEnabled: true,
+      allowsFullscreenVideo: false,
+      injectedJavaScript: `
+        window.addEventListener("message", function(event) {
+          if (window.ReactNativeWebView && event.data) {
+            // ReactNativeWebView.postMessage only supports string data
+            window.ReactNativeWebView.postMessage(JSON.stringify(event.data));
           }
-        });
-        reset();
+        }, false);
+      `,
+      onError: () => {
+        onDebugEvent("InlineAd: error loading iframe", { messageId });
       },
       onLoad: () => {
-        debug("Format:iframeLoad", {
-          params: {
-            messageId,
-            code,
-            otherParams
-          }
-        });
+        onDebugEvent("InlineAd: iframe loaded", { messageId });
       }
     }
   );
-  const interstitialContent = /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-    import_react_native.Modal,
-    {
-      visible: modalOpen,
-      transparent: true,
-      onRequestClose: resetModal,
-      animationType: "slide",
-      statusBarTranslucent: true,
-      children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-        import_react_native.View,
-        {
-          style: {
-            flex: 1,
-            // Don't show the modal until the modal page is loaded and sends 'init-component-iframe' message back to SDK
-            ...modalShown ? { opacity: 1, pointerEvents: "auto" } : { opacity: 0, pointerEvents: "none" }
-          },
-          children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-            frame_webview_default,
-            {
-              ref: modalWebViewRef,
-              iframeUrl: modalUrl,
-              onMessage: onModalMessage,
-              style: {
-                backgroundColor: "transparent",
-                height: "100%",
-                width: "100%",
-                borderWidth: 0
-              },
-              onError: () => {
-                debug("Format:modalError", {
-                  params: {
-                    messageId,
-                    code,
-                    otherParams
-                  }
-                });
-                resetModal();
-              },
-              onLoad: () => {
-                debug("Format:modalLoad", {
-                  params: {
-                    messageId,
-                    code,
-                    otherParams
-                  }
-                });
-                setModalLoaded(true);
-              }
-            }
-          )
-        }
-      )
-    }
-  );
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-      import_react_native.View,
-      {
-        style: isAdViewVisible ? containerStyles : {
-          height: 0,
-          overflow: "hidden"
-        },
-        ref: containerRef,
-        children: wrapper ? wrapper(inlineContent) : inlineContent
-      }
-    ),
-    interstitialContent
-  ] });
 };
-var FormatWithErrorBoundary = (props) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_sdk_react.ErrorBoundary, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Format, { ...props }) });
-var Format_default = FormatWithErrorBoundary;
 
-// src/formats/InlineAd.tsx
-var import_jsx_runtime3 = require("react/jsx-runtime");
-var InlineAd = ({ code, messageId, wrapper, ...props }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Format_default, { code, messageId, wrapper, ...props });
+// src/Configuration.ts
+var DEFAULT_AD_SERVER_URL = "https://server.megabrain.co";
+var DEFAULT_PLACEMENT_CODE = "inlineAd";
+var DEFAULT_LOG_LEVEL = "info";
+var Configuration = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  get publisherToken() {
+    return this.config.publisherToken;
+  }
+  get userId() {
+    return this.config.userId;
+  }
+  get conversationId() {
+    return this.config.conversationId;
+  }
+  get character() {
+    return this.config.character;
+  }
+  get placementCode() {
+    return this.config.placementCode ?? DEFAULT_PLACEMENT_CODE;
+  }
+  get variantId() {
+    return this.config.variantId;
+  }
+  get regulatory() {
+    return this.config.regulatory;
+  }
+  get logLevel() {
+    return this.config.logLevel ?? DEFAULT_LOG_LEVEL;
+  }
+  get userEmail() {
+    return this.config.userEmail;
+  }
+  get adServerUrl() {
+    return this.config.adServerUrl ?? DEFAULT_AD_SERVER_URL;
+  }
 };
-var InlineAd_default = InlineAd;
-
-// src/context/AdsProvider.tsx
-var import_sdk_react2 = require("@kontextso/sdk-react");
-var import_netinfo = require("@react-native-community/netinfo");
-var import_react_native3 = require("react-native");
-var import_react_native_device_info = __toESM(require("react-native-device-info"));
 
-// package.json
-var version = "3.0.7-rc.2";
-
-// src/NativeRNKontext.ts
-var import_react_native2 = require("react-native");
-var NativeRNKontext_default = import_react_native2.TurboModuleRegistry.getEnforcing("RNKontext");
+// src/Logger.ts
+var Logger = class {
+  localLevel = "log";
+  remoteLevel = "error";
+  remoteConfig = null;
+  levels = {
+    debug: 0,
+    info: 1,
+    log: 2,
+    warn: 3,
+    error: 4,
+    silent: 5
+  };
+  getLocalLevel() {
+    return this.localLevel;
+  }
+  setLocalLevel(level) {
+    this.localLevel = level;
+  }
+  getRemoteLevel() {
+    return this.remoteLevel;
+  }
+  setRemoteLevel(level) {
+    this.remoteLevel = level;
+  }
+  configureRemote(url, params) {
+    this.remoteConfig = { url, params };
+  }
+  shouldLog(level, targetLevel) {
+    if (targetLevel === "silent") {
+      return false;
+    }
+    return this.levels[level] >= this.levels[targetLevel];
+  }
+  logToConsole(level, ...args) {
+    if (this.shouldLog(level, this.localLevel)) {
+      if (level === "silent") {
+        return;
+      }
+      console[level](...args);
+    }
+  }
+  logToRemote(level, ...args) {
+    if (this.remoteConfig && this.shouldLog(level, this.remoteLevel)) {
+      fetch(`${this.remoteConfig.url}/log`, {
+        method: "POST",
+        body: JSON.stringify({
+          ...this.remoteConfig.params,
+          level,
+          message: args,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      }).catch((e) => {
+      });
+    }
+  }
+  debug(...args) {
+    this.logToConsole("debug", ...args);
+    this.logToRemote("debug", ...args);
+  }
+  info(...args) {
+    this.logToConsole("info", ...args);
+    this.logToRemote("info", ...args);
+  }
+  log(...args) {
+    this.logToConsole("log", ...args);
+    this.logToRemote("log", ...args);
+  }
+  warn(...args) {
+    this.logToConsole("warn", ...args);
+    this.logToRemote("warn", ...args);
+  }
+  error(...args) {
+    this.logToConsole("error", ...args);
+    this.logToRemote("error", ...args);
+  }
+};
 
-// src/context/AdsProvider.tsx
-var import_jsx_runtime4 = require("react/jsx-runtime");
-ErrorUtils.setGlobalHandler((error, isFatal) => {
-  if (!isFatal) {
-    import_sdk_react2.log.warn(error);
-  } else {
-    import_sdk_react2.log.error(error);
+// src/utils/request.ts
+async function fetchWithRetry(url, options = {}) {
+  const { retry = {}, timeout, abortController: abortControllerOption, ...fetchOptions } = options;
+  const maxRetries = retry.maxRetries ?? 3;
+  const baseDelay = retry.baseDelay ?? 1e3;
+  const backoffFactor = retry.backoffFactor ?? 2;
+  const abortController = abortControllerOption || new AbortController();
+  fetchOptions.signal = abortController.signal;
+  let timeoutId = null;
+  if (timeout) {
+    timeoutId = setTimeout(() => abortController.abort("timeout"), timeout);
   }
-});
-var getDevice = async () => {
-  try {
-    const powerState = await import_react_native_device_info.default.getPowerState();
-    const deviceType = import_react_native_device_info.default.getDeviceType();
-    const soundOn = await NativeRNKontext_default.isSoundOn();
-    const screen = import_react_native3.Dimensions.get("screen");
-    const networkInfo = await (0, import_netinfo.fetch)();
-    const mapDeviceTypeToHardwareType = () => {
-      switch (deviceType) {
-        case "Handset":
-          return "handset";
-        case "Tablet":
-          return "tablet";
-        case "Tv":
-          return "tv";
-        case "Desktop":
-          return "desktop";
-        default:
-          return "other";
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(url, fetchOptions);
+      if (response.status >= 500 || response.status === 429) {
+        const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+        error.status = response.status;
+        throw error;
       }
-    };
-    return {
-      hardware: {
-        brand: import_react_native_device_info.default.getBrand(),
-        model: import_react_native_device_info.default.getDeviceId(),
-        type: mapDeviceTypeToHardwareType()
-        // bootTime: Not available without native module
-        // sdCardAvailable: Not available without native module
-      },
-      audio: {
-        muted: soundOn
-        // volume: Requires react-native-volume-manager
-        // outputPluggedIn: Not available without native module
-        // outputType: Not available without native module
-      },
-      network: {
-        carrier: networkInfo.type === import_netinfo.NetInfoStateType.cellular && networkInfo.details.carrier || void 0,
-        userAgent: await import_react_native_device_info.default.getUserAgent(),
-        type: [import_netinfo.NetInfoStateType.wifi, import_netinfo.NetInfoStateType.cellular, import_netinfo.NetInfoStateType.ethernet].includes(networkInfo.type) ? networkInfo.type : import_netinfo.NetInfoStateType.other,
-        detail: networkInfo.type === import_netinfo.NetInfoStateType.cellular && networkInfo.details.cellularGeneration || void 0
-      },
-      os: {
-        name: import_react_native3.Platform.OS,
-        version: import_react_native_device_info.default.getSystemVersion(),
-        locale: Intl.DateTimeFormat().resolvedOptions().locale,
-        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
-      },
-      screen: {
-        darkMode: import_react_native3.Appearance.getColorScheme() === "dark",
-        dpr: import_react_native3.PixelRatio.get(),
-        height: screen.height,
-        width: screen.width,
-        orientation: screen.width > screen.height ? "landscape" : "portrait"
-      },
-      power: {
-        batteryLevel: powerState.batteryLevel,
-        batteryState: powerState.batteryState,
-        lowPowerMode: powerState.lowPowerMode
+      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");
+      const shouldRetry = error instanceof TypeError || // Network error
+      error.status >= 500 || // Server error
+      error.status === 429;
+      if (attempt === maxRetries || !shouldRetry) {
+        break;
       }
+      const delay = baseDelay * backoffFactor ** attempt;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/Preload.ts
+var Preload = class {
+  session;
+  messages = [];
+  abortController;
+  running = false;
+  bid = null;
+  constructor(session, messages) {
+    this.session = session;
+    this.abortController = new AbortController();
+    this.setMessages(messages);
+  }
+  setMessages(messages) {
+    this.messages = messages;
+  }
+  hasBid() {
+    return this.bid !== null;
+  }
+  getBid() {
+    return this.bid;
+  }
+  setBid(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
+    }
+  }
+  */
+  async getPreloadBody() {
+    const config = this.session.config;
+    const preloadBody = {
+      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
     };
-  } catch (error) {
-    console.error(error);
-    return {};
+    return preloadBody;
+  }
+  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: 16e3,
+        abortController: this.abortController
+      });
+      const jsonResponse = await response.json();
+      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;
+    }
   }
 };
-var getApp = async () => {
-  try {
-    return {
-      bundleId: import_react_native_device_info.default.getBundleId(),
-      firstInstallTime: await import_react_native_device_info.default.getFirstInstallTime(),
-      lastUpdateTime: await import_react_native_device_info.default.getLastUpdateTime(),
-      version: import_react_native_device_info.default.getVersion()
-      // Not supported in react-native-device-info v10
-      // startTime: await DeviceInfo.getStartupTime(),
-    };
-  } catch (error) {
-    console.error(error);
-    return {};
+
+// src/Session.ts
+var Session = class {
+  config;
+  logger;
+  sdk;
+  sessionId = null;
+  sessionDisabled = false;
+  messages = [];
+  bids = [];
+  onUpdateBidsCallback = null;
+  // only one preload instance is allowed at a time
+  preloadInstance = null;
+  constructor(config, { sdk }) {
+    this.config = config;
+    this.logger = new Logger();
+    this.sdk = sdk;
+  }
+  setOnUpdateBids(callback) {
+    this.onUpdateBidsCallback = callback;
+  }
+  isSessionDisabled() {
+    return this.sessionDisabled;
+  }
+  setSessionDisabled(disabled) {
+    this.sessionDisabled = disabled;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  setSessionId(sessionId) {
+    this.logger.info("Session ID set:", sessionId);
+    this.sessionId = sessionId;
+  }
+  addMessage(message) {
+    this.messages.push(message);
+    this.updateBids();
+  }
+  getMessages() {
+    return this.messages;
+  }
+  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];
   }
 };
-var getSdk = async () => ({
-  name: "sdk-react-native",
-  platform: import_react_native3.Platform.OS === "ios" ? "ios" : "android",
-  version
-});
-var AdsProvider = (props) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_sdk_react2.AdsProviderInternal, { ...props, getDevice, getSdk, getApp });
+
+// src/KontextAds.ts
+var import_react_native = require("react-native");
+
+// package.json
+var version = "4.0.0-rc.0";
+
+// src/KontextAds.ts
+var KontextAds = (config) => {
+  return {
+    createSession: (sessionConfig) => createSession({
+      ...config,
+      ...sessionConfig
+    })
+  };
+};
+var createSession = (options) => {
+  const sdk = {
+    name: "sdk-react-native",
+    platform: import_react_native.Platform.OS === "ios" ? "ios" : "android",
+    version
+  };
+  const instance = new Session(new Configuration(options), { sdk });
+  return {
+    addMessage: (message) => {
+      instance.addMessage(message);
+      if (message.role === "user") {
+        instance.preload().requestAd();
+      }
+    },
+    getInstance: () => instance
+  };
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AdsProvider,
-  InlineAd
+  InlineAd,
+  KontextAds
 });