react-native-test-adx 0.1.2 → 0.1.4

package/lib/module/AdaxonSdk.js

@@ -1,18 +1,16 @@
 "use strict";
 
 import { AdaxonClient } from "./core/AdaxonClient.js";
-import { MEDIATION_PROVIDER, OFFER_OPENED_EVENT } from "./config/ApiConstants.js";
+import { MEDIATION_PROVIDER, OFFER_OPENED_EVENT, RECOMMENDATION_VIEW_EVENT } from "./config/ApiConstants.js";
+import { dismissInterstitial, presentInterstitial } from "./components/InterstitialAd.js";
 import { AdaxonSdkError } from "./errors/AdaxonSdkError.js";
 import { detectReactNativePlatform, reactNativeAppInfoReader, reactNativeDeviceReader, reactNativeNetworkInfoReader, reactNativeNetworkStatusReader, reactNativeUrlOpener } from "./platform/reactNative.js";
 import { buildAddToCartProperties, buildPurchaseProperties, normalizeEventValues } from "./services/event/normalizeProperties.js";
 import { AdxEvent } from "./services/event/predefined.js";
 export class AdaxonSdk {
-  static sharedInstance = new AdaxonSdk();
+  static shared = new AdaxonSdk();
   client = null;
   testMode = false;
-  static get shared() {
-    return AdaxonSdk.sharedInstance;
-  }
   isInitialized() {
     return this.client !== null;
   }
@@ -70,58 +68,67 @@ export class AdaxonSdk {
   async trackCompleteRegistration(params = {}, options = {}) {
     return this.logEvent(AdxEvent.COMPLETE_REGISTRATION, params, options);
   }
-  async loadRecommendations(eventName, properties = {}, listener) {
+  async showAd() {
     try {
-      const response = await this.requireClient().getRecommendations({
-        eventName,
-        properties: {
-          ...properties,
-          mediation_provider: MEDIATION_PROVIDER,
-          test_mode: this.testMode
-        }
-      });
-      listener?.onRecommendationsLoaded(response.offers);
-      return response.offers;
-    } catch (error) {
-      const message = AdaxonSdkError.messageOf(error, 'Failed to load recommendations.');
-      const code = error instanceof AdaxonSdkError ? error.code : undefined;
-      listener?.onRecommendationsFailedToLoad(message, code);
-      throw error;
-    }
-  }
-  async showOffer(offer, listener) {
-    try {
-      const client = this.requireClient();
-      const targetUrl = offer.offer_url;
-      const canOpen = await reactNativeUrlOpener.canOpenURL(targetUrl);
-      if (!canOpen) {
-        throw new AdaxonSdkError('VALIDATION_ERROR', `Cannot open offer URL: ${targetUrl}`);
+      const offers = await this.loadRecommendations(RECOMMENDATION_VIEW_EVENT);
+      const offer = offers[0];
+      if (!offer) {
+        console.warn('[Adaxon] No offer available.');
+        return;
+      }
+      if (!this.displayInterstitial(offer)) {
+        console.warn('[Adaxon] Interstitial host is not mounted. Wrap the app in AdaxonProvider.');
       }
-      await reactNativeUrlOpener.openURL(targetUrl);
-      await client.track(OFFER_OPENED_EVENT, {
-        offer_id: offer.offer_id,
-        offer_name: offer.offer_name,
-        ad_type: offer.ad_type,
-        mediation_provider: MEDIATION_PROVIDER
-      });
-      listener?.onOfferOpened(offer);
     } catch (error) {
-      const message = AdaxonSdkError.messageOf(error, 'Failed to open offer.');
-      listener?.onOfferFailedToOpen(offer, message);
-      throw error;
+      console.warn('[Adaxon] Failed to show ad.', AdaxonSdkError.messageOf(error, 'Failed to show ad.'));
+      if (this.testMode) {
+        throw error;
+      }
     }
   }
-  setExternalUserId(externalUserId) {
-    this.requireClient().setExternalUserId(externalUserId);
-  }
   isNetworkAvailable() {
     return this.client?.isNetworkAvailable() ?? false;
   }
   destroy() {
+    dismissInterstitial();
     this.client?.destroy();
     this.client = null;
     this.testMode = false;
   }
+  async loadRecommendations(eventName, properties = {}) {
+    const response = await this.requireClient().getRecommendations({
+      eventName,
+      properties: {
+        ...properties,
+        mediation_provider: MEDIATION_PROVIDER,
+        test_mode: this.testMode
+      }
+    });
+    return response.offers;
+  }
+  displayInterstitial(offer) {
+    return presentInterstitial({
+      offer,
+      interact: () => {
+        this.openOfferUrl(offer).then(dismissInterstitial).catch(error => {
+          console.warn('[Adaxon] Failed to open offer URL.', AdaxonSdkError.messageOf(error, 'Failed to open offer.'));
+        });
+      }
+    });
+  }
+  async openOfferUrl(offer) {
+    const client = this.requireClient();
+    if (!(await reactNativeUrlOpener.canOpenURL(offer.offer_url))) {
+      throw new AdaxonSdkError('VALIDATION_ERROR', `Cannot open offer URL: ${offer.offer_url}`);
+    }
+    await reactNativeUrlOpener.openURL(offer.offer_url);
+    await client.track(OFFER_OPENED_EVENT, {
+      offer_id: offer.offer_id,
+      offer_name: offer.offer_name,
+      ad_type: offer.ad_type,
+      mediation_provider: MEDIATION_PROVIDER
+    });
+  }
   requireClient() {
     if (!this.client) {
       throw new AdaxonSdkError('INVALID_CONFIG', 'Adaxon SDK is not initialized. Call Adaxon.initialize(...) first.');

package/lib/module/components/AdaxonProvider.js

@@ -1,10 +1,12 @@
 "use strict";
 
 import { useEffect, useMemo, useRef, useState } from 'react';
+import { StyleSheet, View } from "../platform/reactNative.js";
 import { AdaxonSdk } from "../AdaxonSdk.js";
 import { AdaxonSdkError } from "../errors/AdaxonSdkError.js";
 import { AdaxonContext } from "../state/AdaxonContext.js";
-import { jsx as _jsx } from "react/jsx-runtime";
+import { InterstitialAd } from "./InterstitialAd.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export function AdaxonProvider({
   configuration,
   listener,
@@ -44,6 +46,14 @@ export function AdaxonProvider({
   }), [initializationError, isInitialized, sdk]);
   return /*#__PURE__*/_jsx(AdaxonContext.Provider, {
     value: value,
-    children: children
+    children: /*#__PURE__*/_jsxs(View, {
+      style: styles.root,
+      children: [children, /*#__PURE__*/_jsx(InterstitialAd, {})]
+    })
   });
-}
+}
+const styles = StyleSheet.create({
+  root: {
+    flex: 1
+  }
+});

package/lib/module/components/InterstitialAd.js

@@ -0,0 +1,279 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { BackHandler, Image, Platform, Pressable, SafeAreaView, StatusBar, StyleSheet, Text, View } from "../platform/reactNative.js";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+const CLOSE_EDGE_INSET = 12;
+const CLOSE_HIT_SIZE = 44;
+let listener = null;
+export function presentInterstitial(session) {
+  if (!listener) {
+    return false;
+  }
+  listener(session);
+  return true;
+}
+export function dismissInterstitial() {
+  listener?.(null);
+}
+const emptySafeAreaInsets = {
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0
+};
+function useEmptySafeAreaInsets() {
+  return emptySafeAreaInsets;
+}
+const useSafeAreaInsets = loadUseSafeAreaInsets() ?? useEmptySafeAreaInsets;
+function loadUseSafeAreaInsets() {
+  try {
+    const module = require('react-native-safe-area-context');
+    return typeof module.useSafeAreaInsets === 'function' ? module.useSafeAreaInsets : undefined;
+  } catch {
+    return undefined;
+  }
+}
+function useTopInset() {
+  const safeArea = useSafeAreaInsets();
+  if (safeArea.top > 0) {
+    return safeArea.top;
+  }
+  if (Platform.OS === 'android') {
+    return StatusBar.currentHeight ?? 0;
+  }
+  return 0;
+}
+export function InterstitialAd() {
+  const [session, setSession] = useState(null);
+  const [closeTone, setCloseTone] = useState('onLightSurface');
+  const safeArea = useSafeAreaInsets();
+  const topInset = useTopInset();
+  const offerId = session?.offer.offer_id;
+  useEffect(() => {
+    listener = setSession;
+    return () => {
+      if (listener === setSession) {
+        listener = null;
+      }
+    };
+  }, []);
+  useEffect(() => {
+    setCloseTone('onLightSurface');
+  }, [offerId]);
+  useEffect(() => {
+    if (!session) {
+      return;
+    }
+    const onBackPress = () => {
+      dismissInterstitial();
+      return true;
+    };
+    const subscription = BackHandler.addEventListener('hardwareBackPress', onBackPress);
+    return () => subscription.remove();
+  }, [session]);
+  if (!session) {
+    return null;
+  }
+  const {
+    offer,
+    interact
+  } = session;
+  const closeAppearance = closeButtonAppearance(closeTone);
+  const closeRightInset = Platform.OS === 'android' ? CLOSE_EDGE_INSET + safeArea.right : CLOSE_EDGE_INSET;
+  const adFrame = /*#__PURE__*/_jsx(_Fragment, {
+    children: /*#__PURE__*/_jsxs(View, {
+      style: styles.adContainer,
+      children: [/*#__PURE__*/_jsx(Pressable, {
+        accessibilityRole: "button",
+        accessibilityLabel: "Close ad",
+        onPress: dismissInterstitial,
+        style: [styles.closeButton, closeAppearance.button, {
+          top: CLOSE_EDGE_INSET,
+          right: closeRightInset
+        }],
+        testID: "adaxon-interstitial-close",
+        children: /*#__PURE__*/_jsx(Text, {
+          style: [styles.closeLabel, closeAppearance.label],
+          children: "\xD7"
+        })
+      }), /*#__PURE__*/_jsx(Pressable, {
+        accessibilityRole: "button",
+        accessibilityLabel: offer.offer_name,
+        onPress: interact,
+        style: styles.offer,
+        testID: "adaxon-interstitial-offer",
+        children: /*#__PURE__*/_jsx(OfferCreative, {
+          offer: offer,
+          onCloseToneChange: setCloseTone
+        })
+      })]
+    })
+  });
+  return /*#__PURE__*/_jsx(View, {
+    style: styles.overlay,
+    testID: "adaxon-interstitial",
+    children: Platform.OS === 'ios' ? /*#__PURE__*/_jsx(SafeAreaView, {
+      style: styles.safeFrame,
+      children: adFrame
+    }) : /*#__PURE__*/_jsx(View, {
+      style: [styles.safeFrame, {
+        paddingTop: topInset
+      }],
+      children: adFrame
+    })
+  });
+}
+function OfferCreative({
+  offer,
+  onCloseToneChange
+}) {
+  const imageUrl = remoteImageUrl(offer.creative_url) ?? remoteImageUrl(offer.preview_url);
+  const [failed, setFailed] = useState(false);
+  useEffect(() => {
+    setFailed(false);
+  }, [imageUrl]);
+  useEffect(() => {
+    if (!imageUrl || failed) {
+      onCloseToneChange('onDarkSurface');
+      return;
+    }
+    onCloseToneChange('onLightSurface');
+  }, [failed, imageUrl, onCloseToneChange]);
+  if (!imageUrl || failed) {
+    return /*#__PURE__*/_jsx(View, {
+      style: styles.fallback,
+      testID: "adaxon-interstitial-fallback",
+      children: /*#__PURE__*/_jsx(Text, {
+        style: styles.offerName,
+        children: offer.offer_name
+      })
+    });
+  }
+  return /*#__PURE__*/_jsx(Image, {
+    source: {
+      uri: imageUrl
+    },
+    style: styles.creativeImage,
+    resizeMode: "contain",
+    onError: () => setFailed(true),
+    testID: "adaxon-interstitial-image"
+  });
+}
+function closeButtonAppearance(tone) {
+  if (tone === 'onDarkSurface') {
+    return {
+      button: {
+        backgroundColor: 'rgba(255, 255, 255, 0.94)',
+        borderColor: 'rgba(0, 0, 0, 0.35)'
+      },
+      label: {
+        color: '#111111',
+        textShadowColor: 'rgba(255, 255, 255, 0.85)',
+        textShadowRadius: 2
+      }
+    };
+  }
+  return {
+    button: {
+      backgroundColor: 'rgba(0, 0, 0, 0.62)',
+      borderColor: 'rgba(255, 255, 255, 0.55)'
+    },
+    label: {
+      color: '#ffffff',
+      textShadowColor: 'rgba(0, 0, 0, 0.75)',
+      textShadowRadius: 3
+    }
+  };
+}
+function remoteImageUrl(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    const url = new URL(trimmed);
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+      return null;
+    }
+    return trimmed;
+  } catch {
+    return null;
+  }
+}
+const styles = StyleSheet.create({
+  overlay: {
+    position: 'absolute',
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    zIndex: 9999,
+    elevation: 9999,
+    backgroundColor: '#000000'
+  },
+  safeFrame: {
+    flex: 1,
+    width: '100%'
+  },
+  adContainer: {
+    flex: 1,
+    width: '100%',
+    position: 'relative'
+  },
+  closeButton: {
+    position: 'absolute',
+    zIndex: 2,
+    minWidth: CLOSE_HIT_SIZE,
+    minHeight: CLOSE_HIT_SIZE,
+    width: CLOSE_HIT_SIZE,
+    height: CLOSE_HIT_SIZE,
+    alignItems: 'center',
+    justifyContent: 'center',
+    borderRadius: CLOSE_HIT_SIZE / 2,
+    borderWidth: 1.5,
+    shadowColor: '#000000',
+    shadowOffset: {
+      width: 0,
+      height: 2
+    },
+    shadowOpacity: 0.45,
+    shadowRadius: 4,
+    elevation: 8
+  },
+  closeLabel: {
+    fontSize: 32,
+    lineHeight: 36,
+    textShadowOffset: {
+      width: 0,
+      height: 0
+    }
+  },
+  offer: {
+    flex: 1,
+    width: '100%',
+    alignSelf: 'stretch',
+    overflow: 'hidden'
+  },
+  creativeImage: {
+    position: 'absolute',
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    width: '100%',
+    height: '100%'
+  },
+  fallback: {
+    flex: 1,
+    width: '100%',
+    alignItems: 'center',
+    justifyContent: 'center',
+    paddingHorizontal: 24
+  },
+  offerName: {
+    color: '#ffffff',
+    fontSize: 22,
+    textAlign: 'center'
+  }
+});

package/lib/module/config/ApiConstants.js

@@ -1,12 +1,14 @@
 "use strict";
 
-export const SDK_VERSION = '0.1.2';
+import packageJson from '../../package.json';
+export const SDK_VERSION = packageJson.version;
 export const MEDIATION_PROVIDER = 'mts';
 export const BASE_URL = 'http://localhost:3002';
 export const EVENT_TRACKING_PATH = '/event/tracking';
 export const RECOMMENDATIONS_PATH = '/api/mts/recommendations';
 export const CLICK_TRACKING_PATH = '/click/tracking';
 export const OFFER_OPENED_EVENT = 'offer_opened';
+export const RECOMMENDATION_VIEW_EVENT = 'recommendation_view';
 export const DEFAULT_TIMEOUT_MS = 10_000;
 export const PUBLIC_IP_LOOKUP_URL = 'https://api.ipify.org?format=json';
 export const PUBLIC_IP_LOOKUP_TIMEOUT_MS = 2_000;

package/lib/module/config/StorageKeys.js

@@ -4,7 +4,7 @@ export const ANONYMOUS_ID_KEY_PREFIX = 'adaxon_sdk.anonymous_id.';
 export const EVENT_QUEUE_META_KEY_PREFIX = 'adaxon_sdk.event_queue.meta.';
 export const EVENT_QUEUE_ITEM_KEY_PREFIX = 'adaxon_sdk.event_queue.item.';
 
-// Expo SecureStore and Keychain-backed adapters only accept alphanumerics
+// Queue adapters (and Keychain-backed stores) only accept alphanumerics
 // plus `.`, `-` and `_`, so app ids are sanitized before use as a key.
 const UNSAFE_STORAGE_KEY_CHARS = /[^A-Za-z0-9._-]/g;
 export function sanitizeStorageId(appId) {

package/lib/module/core/AdaxonClient.js

@@ -11,7 +11,6 @@ import { EventService } from "../services/event/EventService.js";
 import { ApiClient } from "../services/network/ApiClient.js";
 import { NetworkInfoService } from "../services/network/NetworkInfoService.js";
 import { NetworkService } from "../services/network/NetworkService.js";
-import { AnonymousIdService } from "../storage/AnonymousIdService.js";
 import { EventQueueStorage } from "../storage/EventQueueStorage.js";
 import { EventValidator } from "../validation/EventValidator.js";
 export class AdaxonClient {
@@ -27,12 +26,10 @@ export class AdaxonClient {
     const networkInfo = new NetworkInfoService(config.networkInfoReader);
     this.builder = new EventBuilder({
       appId: auth.appId,
-      deviceInfo: new DeviceInfoService(config.platform ?? 'web', config.deviceInfoReader),
+      deviceInfo: new DeviceInfoService(config.platform ?? 'web', config.deviceInfoReader, config.storage, auth.appId),
       appInfo: new AppInfoService(Boolean(config.testMode), config.appInfoReader),
       networkInfo,
-      anonymousId: new AnonymousIdService(auth.appId, config.storage),
-      validator: this.validator,
-      externalUserId: config.externalUserId
+      validator: this.validator
     });
     this.events = new EventService({
       api,
@@ -117,9 +114,6 @@ export class AdaxonClient {
     });
     return `${BASE_URL}${CLICK_TRACKING_PATH}?${query}`;
   }
-  setExternalUserId(externalUserId) {
-    this.builder.setExternalUserId(externalUserId);
-  }
   toQueryString(params) {
     return Object.entries(params).filter(([, value]) => value !== undefined).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join('&');
   }

package/lib/module/hooks/useAdaxon.js

@@ -23,9 +23,7 @@ export function useAdaxon() {
     trackAddToCart: sdk.trackAddToCart.bind(sdk),
     trackLogin: sdk.trackLogin.bind(sdk),
     trackCompleteRegistration: sdk.trackCompleteRegistration.bind(sdk),
-    loadRecommendations: sdk.loadRecommendations.bind(sdk),
-    showOffer: sdk.showOffer.bind(sdk),
-    setExternalUserId: sdk.setExternalUserId.bind(sdk)
+    showAd: sdk.showAd.bind(sdk)
   }), [sdk]);
   return {
     isInitialized,

package/lib/module/platform/app.js

@@ -1,12 +1,53 @@
 "use strict";
 
 import { nonEmptyString, setIfPresent } from "../utils/strings.js";
-export function appFieldsFromNative(constants) {
+export function appFieldsFromNative(...sources) {
+  const value = key => lastPresent(sources, key);
+  const expo = expoConfig(value('expoConfig'), value('manifest'), value('extra'));
   const fields = {};
-  setIfPresent(fields, 'package_name', firstNonEmpty(constants.applicationId, constants.bundleId, constants.androidPackage, constants.iosBundleIdentifier));
-  setIfPresent(fields, 'app_version', firstNonEmpty(constants.nativeApplicationVersion, constants.appVersion, constants.nativeAppVersion));
+  setIfPresent(fields, 'package_name', firstNonEmpty(value('applicationId'), value('bundleId'), value('packageName'), value('androidPackage'), value('iosBundleIdentifier'), asRecord(value('android'))?.package, asRecord(value('ios'))?.bundleIdentifier, asRecord(expo?.android)?.package, asRecord(expo?.ios)?.bundleIdentifier));
+  setIfPresent(fields, 'app_version', firstNonEmpty(value('nativeApplicationVersion'), value('appVersion'), value('nativeAppVersion'), value('version'), expo?.version));
   return fields;
 }
+function expoConfig(expoConfigValue, manifestValue, extraValue) {
+  const manifest = asRecord(manifestValue);
+  return firstRecord(expoConfigValue, asRecord(manifest?.extra)?.expoClient, manifest?.expoClient, manifest, asRecord(extraValue)?.expoClient);
+}
+function lastPresent(sources, key) {
+  let found;
+  for (const source of sources) {
+    if (!source) {
+      continue;
+    }
+    const next = source[key];
+    if (next != null && next !== '') {
+      found = next;
+    }
+  }
+  return found;
+}
+function firstRecord(...values) {
+  for (const value of values) {
+    const record = asRecord(value);
+    if (record) {
+      return record;
+    }
+  }
+  return undefined;
+}
+function asRecord(value) {
+  if (typeof value === 'string') {
+    try {
+      return asRecord(JSON.parse(value));
+    } catch {
+      return undefined;
+    }
+  }
+  if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+    return value;
+  }
+  return undefined;
+}
 function firstNonEmpty(...values) {
   for (const value of values) {
     const next = nonEmptyString(value);