react-native-test-adx 0.1.1

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

@@ -0,0 +1,10 @@
+import type { DeviceInfoReader } from '../../platform/types.js';
+import type { AdaxonDeviceContext, AdaxonPlatform } from '../../types/EventTypes.js';
+export declare class DeviceInfoService {
+    private readonly platform;
+    private readonly reader?;
+    private cached?;
+    constructor(platform: AdaxonPlatform, reader?: DeviceInfoReader | undefined);
+    getDeviceInfo(): AdaxonDeviceContext;
+}
+//# sourceMappingURL=DeviceInfoService.d.ts.map

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

@@ -0,0 +1,19 @@
+import type { EventIngestionResponse } from '../../types/ApiTypes.js';
+import type { EventPayload } from '../../types/EventTypes.js';
+import type { BatchProcessResult } from '../../types/QueuedEvent.js';
+import type { EventQueueService } from './EventQueueService.js';
+type BatchSender = (payloads: readonly EventPayload[]) => Promise<EventIngestionResponse>;
+interface BatchProcessorConfig {
+    queue: EventQueueService;
+    sendBatch: BatchSender;
+}
+export declare class BatchProcessor {
+    private readonly queue;
+    private readonly sendBatch;
+    constructor(config: BatchProcessorConfig);
+    process(): Promise<BatchProcessResult>;
+    private stopped;
+    private result;
+}
+export {};
+//# sourceMappingURL=BatchProcessor.d.ts.map

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

@@ -0,0 +1,25 @@
+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 {
+    appId: string;
+    deviceInfo: DeviceInfoService;
+    appInfo: AppInfoService;
+    networkInfo: NetworkInfoService;
+    anonymousId: AnonymousIdService;
+    validator: EventValidator;
+    externalUserId?: string;
+}
+export declare class EventBuilder {
+    private readonly config;
+    private readonly sessionId;
+    private externalUserId?;
+    constructor(config: EventBuilderConfig);
+    setExternalUserId(externalUserId?: string): void;
+    build(input: TrackEventInput): Promise<EventPayload>;
+}
+export {};
+//# sourceMappingURL=EventBuilder.d.ts.map

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

@@ -0,0 +1,13 @@
+import type { EventQueueStorage } from '../../storage/EventQueueStorage.js';
+import type { EventPayload } from '../../types/EventTypes.js';
+import type { QueuedEvent } from '../../types/QueuedEvent.js';
+export declare class EventQueueService {
+    private readonly storage;
+    constructor(storage: EventQueueStorage);
+    add(payload: EventPayload): Promise<QueuedEvent>;
+    getNextBatch(limit?: number): Promise<QueuedEvent[]>;
+    remove(events: readonly QueuedEvent[]): Promise<void>;
+    tryAcquireProcessorLock(): boolean;
+    releaseProcessorLock(): void;
+}
+//# sourceMappingURL=EventQueueService.d.ts.map

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

@@ -0,0 +1,23 @@
+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 { EventBuilder } from './EventBuilder.js';
+import type { EventValidator } from '../../validation/EventValidator.js';
+interface EventServiceConfig {
+    api: ApiClient;
+    builder: EventBuilder;
+    validator: EventValidator;
+}
+export declare class EventService {
+    private readonly api;
+    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>;
+    private postEvents;
+}
+export {};
+//# sourceMappingURL=EventService.d.ts.map

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

@@ -0,0 +1,26 @@
+import type { EventProperties, EventPropertyValue } from '../../types/EventTypes.js';
+export interface TrackPurchaseParams {
+    order_id?: string;
+    amount?: number;
+    currency?: string;
+    content_id?: string;
+    product_id?: string;
+    [key: string]: EventPropertyValue | undefined;
+}
+export interface TrackAddToCartParams {
+    product_id?: string;
+    price?: number;
+    currency?: string;
+    content_id?: string;
+    quantity?: number;
+    [key: string]: EventPropertyValue | undefined;
+}
+export interface TrackLoginParams {
+    method?: string;
+    [key: string]: EventPropertyValue | undefined;
+}
+export type TrackCompleteRegistrationParams = TrackLoginParams;
+export declare function normalizeEventValues(values: unknown): EventProperties;
+export declare function buildPurchaseProperties(params: TrackPurchaseParams): Record<string, unknown>;
+export declare function buildAddToCartProperties(params: TrackAddToCartParams): Record<string, unknown>;
+//# sourceMappingURL=normalizeProperties.d.ts.map

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

@@ -0,0 +1,14 @@
+export declare const AdxEvent: {
+    readonly PURCHASE: "adx_purchase";
+    readonly ADD_TO_CART: "adx_add_to_cart";
+    readonly LOGIN: "adx_login";
+    readonly COMPLETE_REGISTRATION: "adx_complete_registration";
+};
+export type AdxEventName = (typeof AdxEvent)[keyof typeof AdxEvent];
+export declare const AdxParam: {
+    readonly REVENUE: "adx_revenue";
+    readonly CURRENCY: "adx_currency";
+    readonly CONTENT_ID: "adx_content_id";
+};
+export type AdxParamName = (typeof AdxParam)[keyof typeof AdxParam];
+//# sourceMappingURL=predefined.d.ts.map

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

@@ -0,0 +1,14 @@
+interface ApiClientConfig {
+    sdkKey: string;
+    timeoutMs: number;
+    fetch?: typeof globalThis.fetch;
+}
+export declare class ApiClient {
+    private readonly config;
+    private readonly fetchImplementation;
+    constructor(config: ApiClientConfig);
+    post<TResponse>(path: string, body: unknown): Promise<TResponse>;
+    private parseJson;
+}
+export {};
+//# sourceMappingURL=ApiClient.d.ts.map

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

@@ -0,0 +1,14 @@
+import type { NetworkInfoReader } from '../../platform/types.js';
+import type { AdaxonNetworkContext } from '../../types/EventTypes.js';
+export declare function blankNetworkContext(): AdaxonNetworkContext;
+export declare class NetworkInfoService {
+    private readonly reader?;
+    private readonly lookupPublicIp;
+    private cached?;
+    constructor(reader?: NetworkInfoReader | undefined, lookupPublicIp?: () => Promise<string | undefined>);
+    getNetworkInfo(): Promise<AdaxonNetworkContext>;
+    private collect;
+    private resolvePublicIp;
+}
+export declare function lookupPublicIpAddress(fetchImpl?: typeof fetch | undefined): Promise<string | undefined>;
+//# sourceMappingURL=NetworkInfoService.d.ts.map

package/lib/typescript/src/state/AdaxonContext.d.ts

@@ -0,0 +1,9 @@
+import type { AdaxonSdk } from '../AdaxonSdk.js';
+/** Framework state only — event results are never stored here (avoids re-renders). */
+export interface AdaxonContextValue {
+    isInitialized: boolean;
+    initializationError: string | null;
+    sdk: AdaxonSdk;
+}
+export declare const AdaxonContext: import("react").Context<AdaxonContextValue | null>;
+//# sourceMappingURL=AdaxonContext.d.ts.map

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

@@ -0,0 +1,11 @@
+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

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

@@ -0,0 +1,21 @@
+import type { AdaxonStorageAdapter } from '../types/AdaxonConfig.js';
+import type { QueuedEvent } from '../types/QueuedEvent.js';
+export declare class EventQueueStorage {
+    readonly lockId: string;
+    private readonly storage;
+    private writeChain;
+    constructor(appId: string, storage?: AdaxonStorageAdapter);
+    append(event: Omit<QueuedEvent, 'sequence'>): Promise<QueuedEvent>;
+    getNext(limit: number): Promise<QueuedEvent[]>;
+    remove(events: readonly QueuedEvent[]): Promise<void>;
+    private enqueueWrite;
+    private readMeta;
+    private writeMeta;
+    private readItemValue;
+    private parseQueuedEvent;
+    private isQueuedEvent;
+    private deleteItem;
+    private get metaKey();
+    private itemKey;
+}
+//# sourceMappingURL=EventQueueStorage.d.ts.map

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

@@ -0,0 +1,3 @@
+import type { AdaxonStorageAdapter } from '../types/AdaxonConfig.js';
+export declare function createMemoryStorage(): AdaxonStorageAdapter;
+//# sourceMappingURL=memoryStorage.d.ts.map

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

@@ -0,0 +1,30 @@
+import type { RecommendationOffer } from './ApiTypes.js';
+export interface AdaxonStorageAdapter {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem?(key: string): Promise<void>;
+}
+export interface AdaxonSdkConfig {
+    appId: string;
+    sdkKey: string;
+    externalUserId?: string;
+    storage?: AdaxonStorageAdapter;
+    timeoutMs?: number;
+    fetch?: typeof globalThis.fetch;
+    testMode?: boolean;
+}
+export type AdaxonInitializationConfiguration = AdaxonSdkConfig;
+export type AdaxonInitializationErrorCode = 'INVALID_CONFIG' | 'UNKNOWN';
+export interface AdaxonInitializationListener {
+    onInitializationComplete(): void;
+    onInitializationFailed(error: AdaxonInitializationErrorCode, message: string): void;
+}
+export interface AdaxonRecommendationLoadListener {
+    onRecommendationsLoaded(offers: RecommendationOffer[]): void;
+    onRecommendationsFailedToLoad(message: string, code?: string): void;
+}
+export interface AdaxonOfferShowListener {
+    onOfferOpened(offer: RecommendationOffer): void;
+    onOfferFailedToOpen(offer: RecommendationOffer, message: string): void;
+}
+//# sourceMappingURL=AdaxonConfig.d.ts.map

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

@@ -0,0 +1,31 @@
+export interface EventValidationError {
+    index: number;
+    event_id: string | null;
+    reason: string;
+}
+export interface EventIngestionResponse {
+    success: boolean;
+    message: string;
+    accepted: number;
+    received: number;
+    rejected: number;
+    errors?: EventValidationError[];
+}
+export interface RecommendationOffer {
+    offer_id: number;
+    offer_name: string;
+    preview_url: string | null;
+    ad_type: string;
+    creative_size: string;
+    creative_url: string | null;
+    offer_url: string;
+}
+export interface RecommendationResponse {
+    offers: RecommendationOffer[];
+}
+export interface AdaxonApiErrorBody {
+    success?: boolean;
+    message?: string;
+    errors?: unknown;
+}
+//# sourceMappingURL=ApiTypes.d.ts.map

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

@@ -0,0 +1,65 @@
+export type AdaxonPlatform = 'android' | 'ios' | 'web';
+export type EventPropertyValue = string | number | boolean | null;
+export type EventProperties = Record<string, EventPropertyValue>;
+export interface AdaxonUserContext {
+    external_user_id?: string;
+    anonymous_id: string;
+}
+export interface AdaxonDeviceContext {
+    platform: AdaxonPlatform;
+    os_version?: string;
+    brand?: string;
+    model?: string;
+    language?: string;
+    timezone?: string;
+}
+export interface AdaxonAppContext {
+    package_name?: string;
+    app_version?: string;
+    sdk_version?: string;
+}
+export interface AdaxonSessionContext {
+    session_id?: string;
+}
+export interface AdaxonNetworkContext {
+    connection_type?: string;
+    ip_address?: string;
+    country?: string;
+    region?: string;
+    city?: string;
+}
+export interface TrackEventInput {
+    eventName: string;
+    properties?: EventProperties;
+    eventId?: string;
+    eventTime?: string;
+}
+export type TrackEventOptions = Omit<TrackEventInput, 'eventName' | 'properties'>;
+export interface EventPayload {
+    event_id: string;
+    event_name: string;
+    event_time: string;
+    app_id: string;
+    properties: EventProperties;
+    user: AdaxonUserContext;
+    device: AdaxonDeviceContext;
+    app: AdaxonAppContext;
+    session: AdaxonSessionContext;
+    network: AdaxonNetworkContext;
+}
+export interface RecommendationPayload extends EventPayload {
+    event_type: 'recommendation';
+}
+export interface ClickAttribution {
+    offerId: number;
+    affiliateId: number;
+    advertiserId?: number;
+    affClickId?: string;
+    source?: string;
+    affSub?: string;
+    affSub2?: string;
+    affSub3?: string;
+    affSub4?: string;
+    affSub5?: string;
+}
+//# sourceMappingURL=EventTypes.d.ts.map

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

@@ -0,0 +1,16 @@
+import type { EventPayload } from './EventTypes.js';
+export interface QueuedEvent {
+    queue_id: string;
+    sequence: number;
+    created_at: number;
+    payload: EventPayload;
+}
+export type BatchProcessStatus = 'already_processing' | 'completed' | 'stopped';
+export interface BatchProcessResult {
+    status: BatchProcessStatus;
+    batchesSent: number;
+    eventsProcessed: number;
+    failedQueueIds: string[];
+    error?: unknown;
+}
+//# sourceMappingURL=QueuedEvent.d.ts.map

package/lib/typescript/src/utils/locale.d.ts

@@ -0,0 +1,3 @@
+import type { AdaxonDeviceContext } from '../types/EventTypes.js';
+export declare function readLocaleFields(): Pick<AdaxonDeviceContext, 'language' | 'timezone'>;
+//# sourceMappingURL=locale.d.ts.map

package/lib/typescript/src/utils/strings.d.ts

@@ -0,0 +1,3 @@
+export declare function nonEmptyString(value: unknown): string | undefined;
+export declare function setIfPresent<T extends object, K extends keyof T>(target: T, key: K, value: T[K] | undefined): void;
+//# sourceMappingURL=strings.d.ts.map

package/lib/typescript/src/utils/uuid.d.ts

@@ -0,0 +1,3 @@
+/** UUID v4. Uses Math.random so it works on Hermes without crypto. */
+export declare function createUuid(): string;
+//# sourceMappingURL=uuid.d.ts.map

package/lib/typescript/src/validation/EventValidator.d.ts

@@ -0,0 +1,13 @@
+import type { ClickAttribution, EventProperties, TrackEventInput } from '../types/EventTypes.js';
+export declare class EventValidator {
+    validateBatch(events: {
+        readonly length: number;
+    }): void;
+    validateTrackInput(input: TrackEventInput): void;
+    validateEventName(eventName: string): void;
+    validateProperties(properties: EventProperties): void;
+    validateClickAttribution(attribution: ClickAttribution): void;
+    private validatePositiveInteger;
+    private fail;
+}
+//# sourceMappingURL=EventValidator.d.ts.map

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "react-native-test-adx",
+  "version": "0.1.1",
+  "description": "Adaxon React Native / Expo SDK for event tracking and offer recommendations.",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "react-native": "./lib/module/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/typescript/src/index.d.ts",
+      "react-native": "./lib/module/index.js",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "LICENSE",
+    "README.md",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/*.map",
+    "!**/.*"
+  ],
+  "scripts": {
+    "clean": "del-cli lib",
+    "typecheck": "tsc",
+    "lint": "eslint --config config/eslint.config.mjs \"**/*.{js,ts,tsx}\"",
+    "test": "jest --config config/jest.config.js"
+  },
+  "keywords": [
+    "adaxon",
+    "react-native-adaxon",
+    "react-native-test-adx",
+    "react-native",
+    "expo",
+    "analytics",
+    "tracking",
+    "events",
+    "recommendations",
+    "android",
+    "ios"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://bitbucket.org/rashidmobupps/adaxon-sdk.git"
+  },
+  "author": "Ritesh Rana <ritesh@mobupps.com> (https://bitbucket.org/rashidmobupps)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://bitbucket.org/rashidmobupps/adaxon-sdk/issues"
+  },
+  "homepage": "https://bitbucket.org/rashidmobupps/adaxon-sdk#readme",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^2.1.0",
+    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/js": "9",
+    "@jest/globals": "^29.7.0",
+    "@react-native/babel-preset": "0.85.0",
+    "@react-native/eslint-config": "0.85.0",
+    "@react-native/jest-preset": "0.85.0",
+    "@types/react": "^19.2.0",
+    "@types/react-test-renderer": "^19",
+    "del-cli": "^7.0.0",
+    "eslint": "^9.39.4",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.6",
+    "jest": "^29.7.0",
+    "lefthook": "^2.1.9",
+    "prettier": "^3.8.3",
+    "react": "19.2.3",
+    "react-native": "0.85.0",
+    "react-native-builder-bob": "^0.43.0",
+    "react-test-renderer": "19.2.3",
+    "typescript": "^6.0.3"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "prettier": "./config/prettier.config.mjs",
+  "packageManager": "yarn@4.11.0",
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true,
+          "sourceMaps": false
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  }
+}