react-native-test-adx 0.1.1 → 0.1.3

package/README.md

@@ -36,12 +36,6 @@ import { AdaxonProvider, useAdaxon } from 'react-native-test-adx';
 
 Both packages expose the same API. Only the npm name differs.
 
-Recommended storage helper:
-
-```sh
-npx expo install expo-secure-store
-```
-
 ## Quick start (React Native)
 
 Wrap the app in `AdaxonProvider`. Screens use `useAdaxon()`.
@@ -56,12 +50,12 @@ The SDK owns the tracker host and API paths (`/event/tracking`, `/api/mts/recomm
 |---|---|---|
 | `appId` | **Yes** | None. MTS app id (`adx_…`). |
 | `sdkKey` | **Yes** | None. Sent as the `x-sdk-key` header. |
-| `storage` | No | In-memory. Queue and anonymous id are lost on app restart. |
+| `storage` | No | In-memory event queue and anonymous id. Offline events and the generated id are lost on app restart. |
 | `timeoutMs` | No | `10000` |
 | `testMode` | No | `false` (`sdk_version` gets a `-test` suffix when true) |
 | `externalUserId` | No | Unset |
 
-Pass `storage` in production so the anonymous id and queued events survive restart. The SDK detects the device platform and collects device/app fields automatically. Do **not** pass a tracker URL — requests go to the SDK `BASE_URL`.
+The SDK detects the device platform and collects device/app fields automatically. Do **not** pass a tracker URL — requests go to the SDK `BASE_URL`.
 
 ```tsx
 import {
@@ -70,7 +64,6 @@ import {
   useAdaxon,
   type RecommendationOffer,
 } from 'react-native-adaxon';
-import * as SecureStore from 'expo-secure-store';
 import { Button, Text, View } from 'react-native';
 
 function App() {
@@ -80,11 +73,6 @@ function App() {
         appId: 'adx_your_app_id',
         sdkKey: 'your_sdk_key',
         testMode: __DEV__,
-        storage: {
-          getItem: (key) => SecureStore.getItemAsync(key),
-          setItem: (key, value) => SecureStore.setItemAsync(key, value),
-          removeItem: (key) => SecureStore.deleteItemAsync(key),
-        },
       }}
     >
       <HomeScreen />
@@ -156,6 +144,21 @@ function HomeScreen() {
 
 Do **not** pass device or app fields. The SDK attaches `device` and `app` automatically on every event.
 
+### Anonymous id
+
+`user.anonymous_id` is generated by the SDK. It reads a unique id from React Native `NativeModules` when the host exposes one, otherwise it generates a UUID. The value is cached for the process and written to the configured `storage` adapter so the same id is reused across app launches. No third-party device-info package is required.
+
+### Storage
+
+`storage` is optional. It persists the **event queue** (offline / pending events) and the **anonymous id**. Only `appId` and `sdkKey` are required.
+
+| What you pass | What happens |
+|---|---|
+| No `storage` | The queue and anonymous id stay in memory. Tracking still works. Both are lost if the app closes. |
+| A storage adapter | Queued events and the anonymous id survive restart. |
+
+The adapter is only `getItem` / `setItem` / `removeItem`. You do not implement the queue.
+
 ### Non-component boot
 
 `Adaxon.initialize()` is still available if you are not inside a React tree. Prefer the provider in React Native apps.
@@ -218,16 +221,27 @@ POST /event/tracking
 
 Rules:
 
-- Pending events are stored through the `storage` adapter, so they survive app restart.
+- Pending events are stored through the `storage` adapter when you pass one, so they survive app restart. If you omit `storage`, they stay in memory only.
 - Events are processed in creation order (FIFO).
 - Each request contains at most **100** events. A queue of 250 is sent as 100 + 100 + 50.
 - Events are removed only after the API confirms success (`success: true`). On network, HTTP, or unknown errors they stay in the queue.
 - Only one processor runs at a time for the same app. A second `processPendingEvents()` call returns `already_processing`.
 - Large queues are read 100 events at a time. The SDK does not load the whole queue into memory.
-- On `Adaxon.initialize()` / `AdaxonProvider` mount, pending events start flushing in the background without blocking startup.
+- On `Adaxon.initialize()` / `AdaxonProvider` mount, pending events start flushing in the background without blocking startup when the network is available.
 - Pass `removeItem` on the storage adapter so successful events can be deleted. If it is omitted, the SDK writes an empty value instead.
 
-Expo SecureStore has a small per-key size limit. For a large event queue, use a storage backend that can hold JSON payloads (for example AsyncStorage) and keep SecureStore for the anonymous id if you want.
+## Network loss
+
+The SDK watches connectivity through the host app's NetInfo / Expo Network listener. It does **not** poll.
+
+- Online: `track` / `trackBatch` send immediately, same as before.
+- Offline: events are stored in the event queue and no API request is made.
+- Offline → online: the batch processor is notified once and pending events are flushed. Duplicate `ONLINE` events do not start extra processors.
+- `isNetworkAvailable()` reports the current state. `destroy()` (and Provider unmount) removes the network listener.
+
+A missing or failing network module does not crash the app. Tracking continues as online until the device is known to be offline.
+
+Offline events use the same `storage` adapter as above. Without it, they are held in memory and are lost if the app is closed before the network returns.
 
 ## Automatic device information
 
@@ -253,7 +267,7 @@ Values come from React Native `Platform` (`src/platform/reactNative.ts`). They a
   "app": {
     "package_name": "com.example.app",
     "app_version": "2.4.1",
-    "sdk_version": "0.1.1"
+    "sdk_version": "0.1.3"
   }
 }
 ```
@@ -289,7 +303,7 @@ MTS tracker
 | `src/platform/` | Android/iOS fields. **Only `react-native` import** |
 | `src/config/` | Tracker host, API paths, timeouts, storage key rules |
 | `src/validation/` | Event name, property, and batch-size rules |
-| `src/storage/` | Anonymous user id and persistent event queue |
+| `src/storage/` | Persistent event queue |
 | `example/src/` | Demo app: `App.tsx`, `screens/`, `components/` |
 
 Screens belong in the **host app**, not in the SDK.

package/lib/module/AdaxonSdk.js

@@ -3,7 +3,7 @@
 import { AdaxonClient } from "./core/AdaxonClient.js";
 import { MEDIATION_PROVIDER, OFFER_OPENED_EVENT } from "./config/ApiConstants.js";
 import { AdaxonSdkError } from "./errors/AdaxonSdkError.js";
-import { detectReactNativePlatform, reactNativeAppInfoReader, reactNativeDeviceReader, reactNativeNetworkInfoReader, reactNativeUrlOpener } from "./platform/reactNative.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 {
@@ -18,18 +18,25 @@ export class AdaxonSdk {
   }
   async initialize(configuration, listener) {
     try {
-      this.client = new AdaxonClient({
+      const previous = this.client;
+      const client = new AdaxonClient({
         ...configuration,
         platform: detectReactNativePlatform(),
         deviceInfoReader: reactNativeDeviceReader,
         appInfoReader: reactNativeAppInfoReader,
-        networkInfoReader: reactNativeNetworkInfoReader
+        networkInfoReader: reactNativeNetworkInfoReader,
+        networkStatusReader: reactNativeNetworkStatusReader
       });
+      await client.start();
+      previous?.destroy();
+      this.client = client;
       this.testMode = Boolean(configuration.testMode);
       listener?.onInitializationComplete();
-      this.client.processPendingEvents().catch(() => undefined);
+      if (client.isNetworkAvailable()) {
+        client.processPendingEvents().catch(() => undefined);
+      }
     } catch (error) {
-      this.reset();
+      this.destroy();
       const message = AdaxonSdkError.messageOf(error, 'Initialization failed.');
       const code = error instanceof AdaxonSdkError && error.code === 'INVALID_CONFIG' ? 'INVALID_CONFIG' : 'UNKNOWN';
       listener?.onInitializationFailed(code, message);
@@ -107,14 +114,18 @@ export class AdaxonSdk {
   setExternalUserId(externalUserId) {
     this.requireClient().setExternalUserId(externalUserId);
   }
+  isNetworkAvailable() {
+    return this.client?.isNetworkAvailable() ?? false;
+  }
+  destroy() {
+    this.client?.destroy();
+    this.client = null;
+    this.testMode = false;
+  }
   requireClient() {
     if (!this.client) {
       throw new AdaxonSdkError('INVALID_CONFIG', 'Adaxon SDK is not initialized. Call Adaxon.initialize(...) first.');
     }
     return this.client;
   }
-  reset() {
-    this.client = null;
-    this.testMode = false;
-  }
 }

package/lib/module/components/AdaxonProvider.js

@@ -20,10 +20,12 @@ export function AdaxonProvider({
   useEffect(() => {
     let cancelled = false;
     sdk.initialize(configurationRef.current, listenerRef.current).then(() => {
-      if (!cancelled) {
-        setIsInitialized(true);
-        setInitializationError(null);
+      if (cancelled) {
+        sdk.destroy();
+        return;
       }
+      setIsInitialized(true);
+      setInitializationError(null);
     }).catch(error => {
       if (!cancelled) {
         setIsInitialized(false);
@@ -32,6 +34,7 @@ export function AdaxonProvider({
     });
     return () => {
       cancelled = true;
+      sdk.destroy();
     };
   }, [sdk]);
   const value = useMemo(() => ({

package/lib/module/config/ApiConstants.js

@@ -1,6 +1,6 @@
 "use strict";
 
-export const SDK_VERSION = '0.1.1';
+export const SDK_VERSION = '0.1.3';
 export const MEDIATION_PROVIDER = 'mts';
 export const BASE_URL = 'http://localhost:3002';
 export const EVENT_TRACKING_PATH = '/event/tracking';

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

@@ -10,10 +10,11 @@ import { EventQueueService } from "../services/event/EventQueueService.js";
 import { EventService } from "../services/event/EventService.js";
 import { ApiClient } from "../services/network/ApiClient.js";
 import { NetworkInfoService } from "../services/network/NetworkInfoService.js";
-import { AnonymousIdService } from "../storage/AnonymousIdService.js";
+import { NetworkService } from "../services/network/NetworkService.js";
 import { EventQueueStorage } from "../storage/EventQueueStorage.js";
 import { EventValidator } from "../validation/EventValidator.js";
 export class AdaxonClient {
+  started = false;
   constructor(config) {
     const auth = new AuthenticationService(config);
     this.validator = new EventValidator();
@@ -25,10 +26,9 @@ 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
     });
@@ -42,12 +42,48 @@ export class AdaxonClient {
       queue: this.eventQueue,
       sendBatch: payloads => this.events.sendPayloads(payloads)
     });
+    this.network = new NetworkService(config.networkStatusReader);
+  }
+  async start() {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
+    await this.network.initialize();
+    this.network.subscribe(() => {
+      this.batchProcessor.process().catch(() => undefined);
+    });
+  }
+  destroy() {
+    this.network.destroy();
+    this.started = false;
+  }
+  isNetworkAvailable() {
+    return this.network.isAvailable();
   }
   track(eventName, properties = {}, options = {}) {
-    return this.events.track(eventName, properties, options);
+    return this.trackBatch([{
+      eventName,
+      properties,
+      ...options
+    }]);
   }
-  trackBatch(events) {
-    return this.events.trackBatch(events);
+  async trackBatch(events) {
+    if (this.network.isAvailable()) {
+      return this.events.trackBatch(events);
+    }
+    this.validator.validateBatch(events);
+    const payloads = await Promise.all(events.map(event => this.builder.build(event)));
+    for (const payload of payloads) {
+      await this.eventQueue.add(payload);
+    }
+    return {
+      success: true,
+      message: 'queued',
+      accepted: payloads.length,
+      received: payloads.length,
+      rejected: 0
+    };
   }
   async enqueueEvent(eventName, properties = {}, options = {}) {
     const payload = await this.builder.build({

package/lib/module/platform/network.js

@@ -13,6 +13,26 @@ function publicIpAddress(value) {
   const ip = usableIpAddress(value);
   return ip && !isPrivateIpAddress(ip) ? ip : undefined;
 }
+export function isOnlineFromNativeState(state) {
+  const value = asNativeNetworkState(state);
+  if (!value) {
+    return null;
+  }
+  if (value.isConnected === false || value.isInternetReachable === false) {
+    return false;
+  }
+  const type = nonEmptyString(value.type)?.toLowerCase();
+  if (type === 'none') {
+    return false;
+  }
+  if (value.isConnected === true) {
+    return true;
+  }
+  if (type && type !== 'unknown') {
+    return true;
+  }
+  return null;
+}
 export function connectionTypeFromNativeState(state) {
   const type = nonEmptyString(asNativeNetworkState(state)?.type)?.toLowerCase();
   return type && CONNECTION_TYPES.has(type) ? type : undefined;

package/lib/module/platform/reactNative.js

@@ -1,12 +1,34 @@
 "use strict";
 
-import { Linking, NativeModules, Platform } from 'react-native';
+import { Linking, NativeEventEmitter, NativeModules, Platform } from 'react-native';
 import { nonEmptyString, setIfPresent } from "../utils/strings.js";
 import { readLocaleFields } from "../utils/locale.js";
 import { appFieldsFromNative } from "./app.js";
 import { deviceFieldsFromAndroid } from "./android.js";
 import { deviceFieldsFromIos } from "./ios.js";
-import { connectionTypeFromNativeState, ipAddressFromNativeState, usableIpAddress } from "./network.js";
+import { connectionTypeFromNativeState, ipAddressFromNativeState, isOnlineFromNativeState, usableIpAddress } from "./network.js";
+function nativeModule(name) {
+  return (NativeModules ?? {})[name];
+}
+async function callNative(method, arg) {
+  if (typeof method !== 'function') {
+    return undefined;
+  }
+  try {
+    return await method(arg);
+  } catch {
+    return undefined;
+  }
+}
+function safeUnsubscribe(remove) {
+  return () => {
+    try {
+      remove?.();
+    } catch {
+      // Native unsubscribe can throw after the module is torn down.
+    }
+  };
+}
 export function detectReactNativePlatform() {
   return Platform.OS === 'ios' || Platform.OS === 'android' ? Platform.OS : 'web';
 }
@@ -27,52 +49,85 @@ function collectFromReactNative(platform) {
   Object.assign(device, readLocaleFields());
   return device;
 }
-export const reactNativeDeviceReader = {
-  readDeviceInfo: collectFromReactNative
-};
-export const reactNativeAppInfoReader = {
-  readAppInfo: () => appFieldsFromNative(readNativeAppConstants())
-};
-export const reactNativeNetworkInfoReader = {
-  readNetworkInfo: collectFromNativeNetwork
-};
-export const reactNativeUrlOpener = Linking;
+async function readUniqueIdFromNative() {
+  const deviceInfo = nativeModule('RNDeviceInfo');
+  return nonEmptyString(await callNative(deviceInfo?.getUniqueId)) ?? '';
+}
 function readNativeAppConstants() {
-  const modules = NativeModules ?? {};
-  const expoApp = modules.ExpoApplication;
-  const expoConstants = modules.ExponentConstants;
-  const deviceInfo = modules.RNDeviceInfo;
   return {
-    ...deviceInfo,
-    ...expoConstants,
-    ...expoApp
+    ...nativeModule('RNDeviceInfo'),
+    ...nativeModule('ExponentConstants'),
+    ...nativeModule('ExpoApplication')
   };
 }
-async function readOptionalNative(read) {
+function nativeNetworkModules() {
+  return {
+    netInfo: nativeModule('RNCNetInfo'),
+    expoNetwork: nativeModule('ExpoNetwork')
+  };
+}
+async function readIsOnlineFromNative() {
+  const {
+    netInfo,
+    expoNetwork
+  } = nativeNetworkModules();
+  const fromNetInfo = isOnlineFromNativeState(await callNative(netInfo?.getCurrentState, null));
+  if (fromNetInfo !== null) {
+    return fromNetInfo;
+  }
+  return isOnlineFromNativeState(await callNative(expoNetwork?.getNetworkStateAsync));
+}
+function subscribeNativeNetworkStatus(listener) {
+  const {
+    netInfo,
+    expoNetwork
+  } = nativeNetworkModules();
+  const onState = state => {
+    listener(isOnlineFromNativeState(state));
+  };
   try {
-    return await read();
-  } catch {
-    return undefined;
+    if (netInfo) {
+      const subscription = new NativeEventEmitter(NativeModules.RNCNetInfo).addListener('netInfo.networkStatusDidChange', onState);
+      return safeUnsubscribe(() => subscription.remove());
+    }
+    if (expoNetwork && typeof expoNetwork.addListener === 'function') {
+      const subscription = expoNetwork.addListener('onNetworkStateChanged', onState);
+      return safeUnsubscribe(() => subscription?.remove?.());
+    }
+  } catch (error) {
+    console.error('[Adaxon] Failed to register the network listener', error);
   }
+  return () => undefined;
 }
 async function collectFromNativeNetwork() {
   const network = {};
-  const modules = NativeModules ?? {};
-  const netInfo = modules.RNCNetInfo;
-  const expoNetwork = modules.ExpoNetwork;
-  const getCurrentState = netInfo?.getCurrentState;
-  if (typeof getCurrentState === 'function') {
-    const state = await readOptionalNative(() => getCurrentState(null));
-    setIfPresent(network, 'connection_type', connectionTypeFromNativeState(state));
-    setIfPresent(network, 'ip_address', ipAddressFromNativeState(state));
+  const {
+    netInfo,
+    expoNetwork
+  } = nativeNetworkModules();
+  const state = await callNative(netInfo?.getCurrentState, null);
+  setIfPresent(network, 'connection_type', connectionTypeFromNativeState(state));
+  setIfPresent(network, 'ip_address', ipAddressFromNativeState(state));
+  if (!network.connection_type) {
+    setIfPresent(network, 'connection_type', connectionTypeFromNativeState(await callNative(expoNetwork?.getNetworkStateAsync)));
   }
-  const getNetworkState = expoNetwork?.getNetworkStateAsync;
-  if (!network.connection_type && typeof getNetworkState === 'function') {
-    setIfPresent(network, 'connection_type', connectionTypeFromNativeState(await readOptionalNative(getNetworkState)));
-  }
-  const getIpAddress = expoNetwork?.getIpAddressAsync;
-  if (!network.ip_address && typeof getIpAddress === 'function') {
-    setIfPresent(network, 'ip_address', usableIpAddress(nonEmptyString(await readOptionalNative(getIpAddress))));
+  if (!network.ip_address) {
+    setIfPresent(network, 'ip_address', usableIpAddress(nonEmptyString(await callNative(expoNetwork?.getIpAddressAsync))));
   }
   return network;
-}
+}
+export const reactNativeDeviceReader = {
+  readDeviceInfo: collectFromReactNative,
+  getUniqueId: readUniqueIdFromNative
+};
+export const reactNativeAppInfoReader = {
+  readAppInfo: () => appFieldsFromNative(readNativeAppConstants())
+};
+export const reactNativeNetworkInfoReader = {
+  readNetworkInfo: collectFromNativeNetwork
+};
+export const reactNativeNetworkStatusReader = {
+  getIsOnline: readIsOnlineFromNative,
+  subscribe: subscribeNativeNetworkStatus
+};
+export const reactNativeUrlOpener = Linking;

package/lib/module/services/device/DeviceInfoService.js

@@ -1,22 +1,71 @@
 "use strict";
 
+import { ANONYMOUS_ID_KEY_PREFIX, sanitizeStorageId } from "../../config/StorageKeys.js";
+import { nonEmptyString } from "../../utils/strings.js";
+import { createUuid } from "../../utils/uuid.js";
 export class DeviceInfoService {
-  constructor(platform, reader) {
+  constructor(platform, reader, storage, appId) {
     this.platform = platform;
     this.reader = reader;
+    this.storage = storage;
+    this.anonymousIdKey = storage && appId ? `${ANONYMOUS_ID_KEY_PREFIX}${sanitizeStorageId(appId)}` : undefined;
   }
   getDeviceInfo() {
     if (!this.cached) {
-      try {
-        this.cached = this.reader?.readDeviceInfo(this.platform) ?? {
-          platform: this.platform
-        };
-      } catch {
-        this.cached = {
-          platform: this.platform
-        };
-      }
+      this.cached = this.readDeviceInfo();
     }
     return this.cached;
   }
+  getUniqueId() {
+    if (!this.uniqueIdPromise) {
+      this.uniqueIdPromise = this.resolveUniqueId();
+    }
+    return this.uniqueIdPromise;
+  }
+  readDeviceInfo() {
+    const fallback = {
+      platform: this.platform
+    };
+    try {
+      return this.reader?.readDeviceInfo(this.platform) ?? fallback;
+    } catch {
+      return fallback;
+    }
+  }
+  async resolveUniqueId() {
+    const stored = await this.readStoredId();
+    if (stored) {
+      return stored;
+    }
+    const uniqueId = (await this.readNativeId()) ?? createUuid();
+    await this.writeStoredId(uniqueId);
+    return uniqueId;
+  }
+  async readNativeId() {
+    try {
+      return nonEmptyString(await this.reader?.getUniqueId?.());
+    } catch {
+      return undefined;
+    }
+  }
+  async readStoredId() {
+    if (!this.storage || !this.anonymousIdKey) {
+      return undefined;
+    }
+    try {
+      return nonEmptyString(await this.storage.getItem(this.anonymousIdKey));
+    } catch {
+      return undefined;
+    }
+  }
+  async writeStoredId(uniqueId) {
+    if (!this.storage || !this.anonymousIdKey) {
+      return;
+    }
+    try {
+      await this.storage.setItem(this.anonymousIdKey, uniqueId);
+    } catch {
+      // Persistence must not block tracking.
+    }
+  }
 }

package/lib/module/services/event/EventBuilder.js

@@ -15,14 +15,13 @@ export class EventBuilder {
     const {
       validator,
       appId,
-      anonymousId,
       deviceInfo,
       appInfo,
       networkInfo
     } = this.config;
     validator.validateTrackInput(input);
     const user = {
-      anonymous_id: await anonymousId.getAnonymousId()
+      anonymous_id: await deviceInfo.getUniqueId()
     };
     setIfPresent(user, 'external_user_id', nonEmptyString(this.externalUserId));
     return {

package/lib/module/services/event/EventService.js

@@ -8,13 +8,6 @@ export class EventService {
     this.builder = config.builder;
     this.validator = config.validator;
   }
-  track(eventName, properties = {}, options = {}) {
-    return this.trackBatch([{
-      eventName,
-      properties,
-      ...options
-    }]);
-  }
   async trackBatch(events) {
     this.validator.validateBatch(events);
     const payloads = await Promise.all(events.map(event => this.builder.build(event)));

package/lib/module/services/network/NetworkService.js

@@ -0,0 +1,82 @@
+"use strict";
+
+function toState(isOnline) {
+  if (isOnline === true) {
+    return 'ONLINE';
+  }
+  if (isOnline === false) {
+    return 'OFFLINE';
+  }
+  return 'UNKNOWN';
+}
+export class NetworkService {
+  state = 'UNKNOWN';
+  started = false;
+  listeners = new Set();
+  constructor(reader) {
+    this.reader = reader;
+  }
+  getState() {
+    return this.state;
+  }
+  isAvailable() {
+    return this.state !== 'OFFLINE';
+  }
+  async initialize() {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
+    if (!this.reader) {
+      this.applyState('ONLINE');
+      return;
+    }
+    try {
+      this.applyState(toState(await this.reader.getIsOnline()));
+    } catch (error) {
+      console.error('[Adaxon] Network monitoring failed', error);
+      this.applyState('UNKNOWN');
+    }
+    try {
+      this.unsubscribeReader = this.reader.subscribe(isOnline => {
+        this.applyState(toState(isOnline));
+      });
+    } catch (error) {
+      console.error('[Adaxon] Network monitoring failed', error);
+      this.applyState('UNKNOWN');
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  destroy() {
+    try {
+      this.unsubscribeReader?.();
+    } catch (error) {
+      console.error('[Adaxon] Failed to remove the network listener', error);
+    }
+    this.unsubscribeReader = undefined;
+    this.started = false;
+    this.listeners.clear();
+  }
+  applyState(next) {
+    const previous = this.state;
+    if (previous === next) {
+      return;
+    }
+    this.state = next;
+    if (previous !== 'OFFLINE' || next !== 'ONLINE') {
+      return;
+    }
+    for (const listener of [...this.listeners]) {
+      try {
+        listener();
+      } catch (error) {
+        console.error('[Adaxon] Network listener failed', error);
+      }
+    }
+  }
+}

package/lib/typescript/src/AdaxonSdk.d.ts

@@ -22,7 +22,8 @@ export declare class AdaxonSdk {
     loadRecommendations(eventName: string, properties?: EventProperties, listener?: AdaxonRecommendationLoadListener): Promise<RecommendationOffer[]>;
     showOffer(offer: RecommendationOffer, listener?: AdaxonOfferShowListener): Promise<void>;
     setExternalUserId(externalUserId?: string): void;
+    isNetworkAvailable(): boolean;
+    destroy(): void;
     private requireClient;
-    private reset;
 }
 //# sourceMappingURL=AdaxonSdk.d.ts.map

package/lib/typescript/src/config/ApiConstants.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "0.1.1";
+export declare const SDK_VERSION = "0.1.3";
 export declare const MEDIATION_PROVIDER = "mts";
 export declare const BASE_URL = "http://localhost:3002";
 export declare const EVENT_TRACKING_PATH = "/event/tracking";

package/lib/typescript/src/core/AdaxonClient.d.ts

@@ -1,4 +1,4 @@
-import type { AppInfoReader, DeviceInfoReader, NetworkInfoReader } from '../platform/types.js';
+import type { AppInfoReader, DeviceInfoReader, NetworkInfoReader, NetworkStatusReader } from '../platform/types.js';
 import type { AdaxonSdkConfig } from '../types/AdaxonConfig.js';
 import type { EventIngestionResponse, RecommendationResponse } from '../types/ApiTypes.js';
 import type { AdaxonPlatform, ClickAttribution, EventProperties, TrackEventInput, TrackEventOptions } from '../types/EventTypes.js';
@@ -8,6 +8,7 @@ interface AdaxonClientConfig extends AdaxonSdkConfig {
     deviceInfoReader?: DeviceInfoReader;
     appInfoReader?: AppInfoReader;
     networkInfoReader?: NetworkInfoReader;
+    networkStatusReader?: NetworkStatusReader;
 }
 export declare class AdaxonClient {
     private readonly events;
@@ -15,7 +16,12 @@ export declare class AdaxonClient {
     private readonly validator;
     private readonly eventQueue;
     private readonly batchProcessor;
+    private readonly network;
+    private started;
     constructor(config: AdaxonClientConfig);
+    start(): Promise<void>;
+    destroy(): void;
+    isNetworkAvailable(): boolean;
     track(eventName: string, properties?: EventProperties, options?: TrackEventOptions): Promise<EventIngestionResponse>;
     trackBatch(events: readonly TrackEventInput[]): Promise<EventIngestionResponse>;
     enqueueEvent(eventName: string, properties?: EventProperties, options?: TrackEventOptions): Promise<void>;

package/lib/typescript/src/platform/network.d.ts

@@ -1,3 +1,4 @@
+export declare function isOnlineFromNativeState(state: unknown): boolean | null;
 export declare function connectionTypeFromNativeState(state: unknown): string | undefined;
 export declare function ipAddressFromNativeState(state: unknown): string | undefined;
 export declare function usableIpAddress(value: string | undefined): string | undefined;

package/lib/typescript/src/platform/reactNative.d.ts

@@ -1,8 +1,9 @@
 import type { AdaxonPlatform } from '../types/EventTypes.js';
-import type { AppInfoReader, DeviceInfoReader, NetworkInfoReader, UrlOpener } from './types.js';
+import type { AppInfoReader, DeviceInfoReader, NetworkInfoReader, NetworkStatusReader, UrlOpener } from './types.js';
 export declare function detectReactNativePlatform(): AdaxonPlatform;
 export declare const reactNativeDeviceReader: DeviceInfoReader;
 export declare const reactNativeAppInfoReader: AppInfoReader;
 export declare const reactNativeNetworkInfoReader: NetworkInfoReader;
+export declare const reactNativeNetworkStatusReader: NetworkStatusReader;
 export declare const reactNativeUrlOpener: UrlOpener;
 //# sourceMappingURL=reactNative.d.ts.map

package/lib/typescript/src/platform/types.d.ts

@@ -1,6 +1,7 @@
 import type { AdaxonAppContext, AdaxonDeviceContext, AdaxonNetworkContext, AdaxonPlatform } from '../types/EventTypes.js';
 export interface DeviceInfoReader {
     readDeviceInfo(platform: AdaxonPlatform): AdaxonDeviceContext;
+    getUniqueId?(): Promise<string>;
 }
 export interface AppInfoReader {
     readAppInfo(): AdaxonAppContext;
@@ -12,4 +13,8 @@ export interface UrlOpener {
     canOpenURL(url: string): Promise<boolean>;
     openURL(url: string): Promise<void>;
 }
+export interface NetworkStatusReader {
+    getIsOnline(): Promise<boolean | null>;
+    subscribe(listener: (isOnline: boolean | null) => void): () => void;
+}
 //# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/services/device/DeviceInfoService.d.ts

@@ -1,10 +1,20 @@
 import type { DeviceInfoReader } from '../../platform/types.js';
+import type { AdaxonStorageAdapter } from '../../types/AdaxonConfig.js';
 import type { AdaxonDeviceContext, AdaxonPlatform } from '../../types/EventTypes.js';
 export declare class DeviceInfoService {
     private readonly platform;
     private readonly reader?;
+    private readonly storage?;
     private cached?;
-    constructor(platform: AdaxonPlatform, reader?: DeviceInfoReader | undefined);
+    private uniqueIdPromise?;
+    private readonly anonymousIdKey?;
+    constructor(platform: AdaxonPlatform, reader?: DeviceInfoReader | undefined, storage?: AdaxonStorageAdapter | undefined, appId?: string);
     getDeviceInfo(): AdaxonDeviceContext;
+    getUniqueId(): Promise<string>;
+    private readDeviceInfo;
+    private resolveUniqueId;
+    private readNativeId;
+    private readStoredId;
+    private writeStoredId;
 }
 //# sourceMappingURL=DeviceInfoService.d.ts.map

package/lib/typescript/src/services/event/EventBuilder.d.ts

@@ -1,7 +1,6 @@
 import type { AppInfoService } from '../app/AppInfoService.js';
 import type { DeviceInfoService } from '../device/DeviceInfoService.js';
 import type { NetworkInfoService } from '../network/NetworkInfoService.js';
-import type { AnonymousIdService } from '../../storage/AnonymousIdService.js';
 import type { EventPayload, TrackEventInput } from '../../types/EventTypes.js';
 import type { EventValidator } from '../../validation/EventValidator.js';
 interface EventBuilderConfig {
@@ -9,7 +8,6 @@ interface EventBuilderConfig {
     deviceInfo: DeviceInfoService;
     appInfo: AppInfoService;
     networkInfo: NetworkInfoService;
-    anonymousId: AnonymousIdService;
     validator: EventValidator;
     externalUserId?: string;
 }

package/lib/typescript/src/services/event/EventService.d.ts

@@ -1,6 +1,6 @@
 import type { ApiClient } from '../network/ApiClient.js';
 import type { EventIngestionResponse, RecommendationResponse } from '../../types/ApiTypes.js';
-import type { EventPayload, EventProperties, TrackEventInput, TrackEventOptions } from '../../types/EventTypes.js';
+import type { EventPayload, TrackEventInput } from '../../types/EventTypes.js';
 import type { EventBuilder } from './EventBuilder.js';
 import type { EventValidator } from '../../validation/EventValidator.js';
 interface EventServiceConfig {
@@ -13,7 +13,6 @@ export declare class EventService {
     private readonly builder;
     private readonly validator;
     constructor(config: EventServiceConfig);
-    track(eventName: string, properties?: EventProperties, options?: TrackEventOptions): Promise<EventIngestionResponse>;
     trackBatch(events: readonly TrackEventInput[]): Promise<EventIngestionResponse>;
     sendPayloads(payloads: readonly EventPayload[]): Promise<EventIngestionResponse>;
     getRecommendations(input: TrackEventInput): Promise<RecommendationResponse>;

package/lib/typescript/src/services/network/NetworkService.d.ts

@@ -0,0 +1,17 @@
+import type { NetworkStatusReader } from '../../platform/types.js';
+export type NetworkState = 'ONLINE' | 'OFFLINE' | 'UNKNOWN';
+export declare class NetworkService {
+    private readonly reader?;
+    private state;
+    private started;
+    private unsubscribeReader?;
+    private readonly listeners;
+    constructor(reader?: NetworkStatusReader | undefined);
+    getState(): NetworkState;
+    isAvailable(): boolean;
+    initialize(): Promise<void>;
+    subscribe(listener: () => void): () => void;
+    destroy(): void;
+    private applyState;
+}
+//# sourceMappingURL=NetworkService.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-test-adx",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Adaxon React Native / Expo SDK for event tracking and offer recommendations.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/lib/module/storage/AnonymousIdService.js

@@ -1,31 +0,0 @@
-"use strict";
-
-import { ANONYMOUS_ID_KEY_PREFIX, sanitizeStorageId } from "../config/StorageKeys.js";
-import { createUuid } from "../utils/uuid.js";
-export class AnonymousIdService {
-  constructor(appId, storage) {
-    this.appId = appId;
-    this.storage = storage;
-  }
-  getAnonymousId() {
-    if (!this.anonymousIdPromise) {
-      this.anonymousIdPromise = this.loadOrCreate().catch(error => {
-        this.anonymousIdPromise = undefined;
-        throw error;
-      });
-    }
-    return this.anonymousIdPromise;
-  }
-  get storageKey() {
-    return `${ANONYMOUS_ID_KEY_PREFIX}${sanitizeStorageId(this.appId)}`;
-  }
-  async loadOrCreate() {
-    const stored = await this.storage?.getItem(this.storageKey);
-    if (stored) {
-      return stored;
-    }
-    const anonymousId = createUuid();
-    await this.storage?.setItem(this.storageKey, anonymousId);
-    return anonymousId;
-  }
-}

package/lib/typescript/src/storage/AnonymousIdService.d.ts

@@ -1,11 +0,0 @@
-import type { AdaxonStorageAdapter } from '../types/AdaxonConfig.js';
-export declare class AnonymousIdService {
-    private readonly appId;
-    private readonly storage?;
-    private anonymousIdPromise?;
-    constructor(appId: string, storage?: AdaxonStorageAdapter | undefined);
-    getAnonymousId(): Promise<string>;
-    private get storageKey();
-    private loadOrCreate;
-}
-//# sourceMappingURL=AnonymousIdService.d.ts.map