react-native-test-adx 0.1.1 → 0.1.2

package/README.md

@@ -36,11 +36,7 @@ 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
-```
+`expo-secure-store` is **not** required. The SDK does not depend on it.
 
 ## Quick start (React Native)
 
@@ -61,7 +57,7 @@ The SDK owns the tracker host and API paths (`/event/tracking`, `/api/mts/recomm
 | `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 +66,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 +75,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 +146,41 @@ function HomeScreen() {
 
 Do **not** pass device or app fields. The SDK attaches `device` and `app` automatically on every event.
 
+### Storage
+
+`storage` is optional. You do not have to install `expo-secure-store` (or any other store) for the SDK to run. Only `appId` and `sdkKey` are required.
+
+| What you pass | What happens |
+|---|---|
+| No `storage` | SDK uses built-in in-memory storage. Tracking works. Anonymous id and queued events are lost when the app closes. |
+| A storage adapter | Anonymous id and queued events survive restart. |
+
+The adapter is only `getItem` / `setItem` / `removeItem`. You do not implement the queue. Any store works: Expo SecureStore, AsyncStorage, MMKV, or your own.
+
+Optional SecureStore helper (not required):
+
+```sh
+npx expo install expo-secure-store
+```
+
+```tsx
+import * as SecureStore from 'expo-secure-store';
+
+<AdaxonProvider
+  configuration={{
+    appId: 'adx_your_app_id',
+    sdkKey: 'your_sdk_key',
+    storage: {
+      getItem: (key) => SecureStore.getItemAsync(key),
+      setItem: (key, value) => SecureStore.setItemAsync(key, value),
+      removeItem: (key) => SecureStore.deleteItemAsync(key),
+    },
+  }}
+>
+```
+
+SecureStore has a small per-key size limit. For a large event queue, prefer AsyncStorage (or similar) and keep SecureStore for the anonymous id if you want.
+
 ### 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 +243,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 +289,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.2"
   }
 }
 ```

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.2';
 export const MEDIATION_PROVIDER = 'mts';
 export const BASE_URL = 'http://localhost:3002';
 export const EVENT_TRACKING_PATH = '/event/tracking';

package/lib/module/core/AdaxonClient.js

@@ -10,10 +10,12 @@ 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 { 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 {
+  started = false;
   constructor(config) {
     const auth = new AuthenticationService(config);
     this.validator = new EventValidator();
@@ -42,12 +44,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,12 @@
 "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";
 export function detectReactNativePlatform() {
   return Platform.OS === 'ios' || Platform.OS === 'android' ? Platform.OS : 'web';
 }
@@ -36,6 +36,10 @@ export const reactNativeAppInfoReader = {
 export const reactNativeNetworkInfoReader = {
   readNetworkInfo: collectFromNativeNetwork
 };
+export const reactNativeNetworkStatusReader = {
+  getIsOnline: readIsOnlineFromNative,
+  subscribe: subscribeNativeNetworkStatus
+};
 export const reactNativeUrlOpener = Linking;
 function readNativeAppConstants() {
   const modules = NativeModules ?? {};
@@ -48,6 +52,63 @@ function readNativeAppConstants() {
     ...expoApp
   };
 }
+function nativeNetworkModules() {
+  const modules = NativeModules ?? {};
+  return {
+    netInfo: modules.RNCNetInfo,
+    expoNetwork: modules.ExpoNetwork
+  };
+}
+function safeUnsubscribe(remove) {
+  return () => {
+    try {
+      remove?.();
+    } catch {
+      // Native unsubscribe can throw after the module is torn down.
+    }
+  };
+}
+async function readIsOnlineFromNative() {
+  const {
+    netInfo,
+    expoNetwork
+  } = nativeNetworkModules();
+  const getCurrentState = netInfo?.getCurrentState;
+  if (typeof getCurrentState === 'function') {
+    const online = isOnlineFromNativeState(await readOptionalNative(() => getCurrentState(null)));
+    if (online !== null) {
+      return online;
+    }
+  }
+  const getNetworkState = expoNetwork?.getNetworkStateAsync;
+  if (typeof getNetworkState === 'function') {
+    return isOnlineFromNativeState(await readOptionalNative(getNetworkState));
+  }
+  return null;
+}
+function subscribeNativeNetworkStatus(listener) {
+  const {
+    netInfo,
+    expoNetwork
+  } = nativeNetworkModules();
+  const onState = state => {
+    listener(isOnlineFromNativeState(state));
+  };
+  try {
+    if (netInfo) {
+      const subscription = new NativeEventEmitter(NativeModules.RNCNetInfo).addListener('netInfo.networkStatusDidChange', onState);
+      return safeUnsubscribe(() => subscription.remove());
+    }
+    const addListener = expoNetwork?.addListener;
+    if (typeof addListener === 'function') {
+      const subscription = addListener.call(expoNetwork, 'onNetworkStateChanged', onState);
+      return safeUnsubscribe(() => subscription?.remove?.());
+    }
+  } catch (error) {
+    console.error('[Adaxon] Failed to register the network listener', error);
+  }
+  return () => undefined;
+}
 async function readOptionalNative(read) {
   try {
     return await read();
@@ -57,9 +118,10 @@ async function readOptionalNative(read) {
 }
 async function collectFromNativeNetwork() {
   const network = {};
-  const modules = NativeModules ?? {};
-  const netInfo = modules.RNCNetInfo;
-  const expoNetwork = modules.ExpoNetwork;
+  const {
+    netInfo,
+    expoNetwork
+  } = nativeNetworkModules();
   const getCurrentState = netInfo?.getCurrentState;
   if (typeof getCurrentState === 'function') {
     const state = await readOptionalNative(() => getCurrentState(null));

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.2";
 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

@@ -12,4 +12,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/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.2",
   "description": "Adaxon React Native / Expo SDK for event tracking and offer recommendations.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",