@bytem/bytem-tracker-app 0.0.6 → 0.0.7

package/README.md

@@ -2,6 +2,10 @@
 
 This is the official Bytem Tracker SDK for React Native applications.
 
+## Documentation
+
+- [Usage Guide](docs/USAGE.md): Detailed instructions on initialization, event tracking, and API usage.
+
 ## Installation
 
 Install the package and its peer dependencies using Yarn:
@@ -60,95 +64,3 @@ Notes:
 - These scripts bump package.json version and publish to npm.
 - `prepublishOnly` builds the package before publishing.
 - Configure auth via user-level `~/.npmrc`. Do not commit tokens in the repo.
-## Usage
-
-### Initialization
-Initialize the tracker in your app entry point (e.g., `App.tsx` or `index.js`). Note that `init` is asynchronous.
-
-```typescript
-import React, { useEffect } from 'react';
-import BytemTracker from '@bytem/bytem-tracker-app';
-
-const App = () => {
-  useEffect(() => {
-    const initTracker = async () => {
-      await BytemTracker.init({
-        appId: 'your-app-id',
-        endpoint: 'https://api.bytem.com/track',
-        debug: __DEV__, // Enable debug logs in development
-      });
-    };
-
-    initTracker();
-  }, []);
-
-  return <YourApp />;
-};
-```
-
-### Tracking Events
-
-#### Identify User
-Track user identification when a user logs in or updates their profile.
-
-```typescript
-// Signature: trackUser(userId: string, traits?: object)
-BytemTracker.trackUser('user_12345', {
-  email: 'user@example.com',
-  age: 25,
-  membership: 'gold'
-});
-```
-
-#### View Product
-Track when a user views a product details page.
-
-```typescript
-BytemTracker.trackViewProduct({
-  productId: 'prod_001',
-  name: 'Awesome Gadget',
-  price: 99.99,
-  currency: 'USD',
-  category: 'Electronics'
-});
-```
-
-#### Checkout Order
-Track when a user initiates checkout.
-
-```typescript
-BytemTracker.trackCheckOutOrder({
-  orderId: 'order_abc123',
-  total: 150.00,
-  currency: 'USD',
-  products: [
-    { productId: 'prod_001', price: 99.99, quantity: 1 },
-    { productId: 'prod_002', price: 50.01, quantity: 1 }
-  ]
-});
-```
-
-#### Pay Order
-Track when a user completes a payment.
-
-```typescript
-BytemTracker.trackPayOrder({
-  orderId: 'order_abc123',
-  total: 150.00,
-  currency: 'USD',
-  products: [
-    { productId: 'prod_001', price: 99.99, quantity: 1 },
-    { productId: 'prod_002', price: 50.01, quantity: 1 }
-  ]
-});
-```
-
-## Platform Compatibility
-
-This SDK is designed for **React Native** and supports:
-- iOS
-- Android
-
-It relies on:
-- `@react-native-async-storage/async-storage`: For persisting session and visitor IDs.
-- `react-native-device-info`: For capturing device metrics (model, OS version, etc.).

package/dist/src/BytemTracker.d.ts

@@ -1,18 +1,58 @@
 import { TrackerConfig, Product, Order, UserTraits } from './types';
 declare class BytemTracker {
     private static instance;
-    private config;
-    private isInitialized;
-    private visitorId;
+    private readonly SDK_NAME;
+    private readonly SDK_VERSION;
     private readonly DEFAULT_ENDPOINT;
+    private readonly DEFAULT_API_PATH;
+    private appKey;
+    private baseUrl;
+    private debug;
+    private visitorId;
+    private deviceIdType;
+    private appScheme;
+    private apiPath;
+    private isInitialized;
+    private sessionStarted;
+    private useSessionCookie;
+    private sessionCookieTimeout;
+    private lastBeat;
+    private trackTime;
+    private storedDuration;
+    private lastViewTime;
+    private lastViewStoredDuration;
     private constructor();
     static getInstance(): BytemTracker;
     init(config: TrackerConfig): Promise<void>;
-    private track;
-    trackViewProduct(product: Product): void;
-    trackCheckOutOrder(order: Order): void;
-    trackPayOrder(order: Order): void;
-    trackUser(userId: string, traits?: UserTraits): void;
+    private ensureInitialized;
+    beginSession(force?: boolean): Promise<void>;
+    sessionDuration(sec: number): Promise<void>;
+    endSession(sec?: number, force?: boolean): Promise<void>;
+    trackSessions(): Promise<void>;
+    startTime(): void;
+    stopTime(): void;
+    trackEvent(eventKey: string, segmentation?: Record<string, any>, count?: number, sum?: number, duration?: number): Promise<void>;
+    trackPageview(current: string, referrer?: string): Promise<void>;
+    trackGoodsClick(params: {
+        gid?: string;
+        skuid?: string;
+        url: string;
+        source?: string;
+        position?: string;
+        current?: string;
+        referrer?: string;
+    }): Promise<void>;
+    private reportViewDuration;
+    private getRealDeviceId;
+    private getMetrics;
+    private buildBaseRequestParams;
+    private extendSession;
+    private sendRequest;
+    trackViewProduct(product: Product): Promise<void>;
+    trackCheckOutOrder(order: Order): Promise<void>;
+    trackPayOrder(order: Order): Promise<void>;
+    trackUser(userId: string, traits?: UserTraits): Promise<void>;
+    private sendUserDetails;
 }
 declare const _default: BytemTracker;
 export default _default;

package/dist/src/BytemTracker.js

@@ -1,50 +1,33 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-const base_1 = require("./core/base");
-const request_1 = require("./core/request");
-const Business = __importStar(require("./business"));
-const session_1 = require("./core/session");
+const types_1 = require("./types");
 const storage_1 = require("./core/storage");
 const device_1 = require("./core/device");
 class BytemTracker {
     constructor() {
-        this.config = null;
-        this.isInitialized = false;
+        // SDK Constants
+        this.SDK_NAME = 'react_native_bytem';
+        this.SDK_VERSION = '0.0.1'; // Should match package.json
+        this.DEFAULT_ENDPOINT = 'https://tracking.server.bytecon.com';
+        this.DEFAULT_API_PATH = '/i';
+        // Config
+        this.appKey = null;
+        this.baseUrl = this.DEFAULT_ENDPOINT;
+        this.debug = false;
         this.visitorId = null;
-        this.DEFAULT_ENDPOINT = 'https://tracking.server.bytecon.com/i';
+        this.deviceIdType = 1; // 1: Auto-generated
+        this.appScheme = null;
+        this.apiPath = this.DEFAULT_API_PATH;
+        this.isInitialized = false;
+        // Session Management
+        this.sessionStarted = false;
+        this.useSessionCookie = true;
+        this.sessionCookieTimeout = 30; // minutes
+        this.lastBeat = null;
+        this.trackTime = true;
+        this.storedDuration = 0;
+        this.lastViewTime = 0;
+        this.lastViewStoredDuration = 0;
     }
     static getInstance() {
         if (!BytemTracker.instance) {
@@ -57,79 +40,435 @@ class BytemTracker {
             console.warn('[BytemTracker] Already initialized');
             return;
         }
-        this.config = config;
-        this.isInitialized = true;
+        this.appKey = config.appId;
+        if (config.endpoint) {
+            this.baseUrl = config.endpoint;
+        }
+        this.debug = !!config.debug;
+        this.appScheme = config.appScheme || null;
+        if (config.path) {
+            this.apiPath = config.path.startsWith('/') ? config.path : '/' + config.path;
+        }
         // Initialize Visitor ID
         if (config.visitorId) {
             this.visitorId = config.visitorId;
             await (0, storage_1.setItem)(storage_1.StorageKeys.VISITOR_ID, this.visitorId);
+            if (this.debug)
+                console.log(`[BytemTracker] Using provided visitor ID: ${this.visitorId}`);
         }
         else {
             this.visitorId = await (0, storage_1.getItem)(storage_1.StorageKeys.VISITOR_ID);
             if (!this.visitorId) {
                 this.visitorId = (0, device_1.generateUUID)();
                 await (0, storage_1.setItem)(storage_1.StorageKeys.VISITOR_ID, this.visitorId);
+                if (this.debug)
+                    console.log(`[BytemTracker] Generated new visitor ID: ${this.visitorId}`);
+            }
+            else {
+                if (this.debug)
+                    console.log(`[BytemTracker] Restored visitor ID: ${this.visitorId}`);
             }
         }
-        // Initialize Session
-        await (0, session_1.initSession)();
-        if (!this.config.endpoint) {
-            this.config.endpoint = this.DEFAULT_ENDPOINT;
+        // Initialize Device ID type
+        if (config.deviceId) {
+            this.deviceIdType = 0; // Developer set
+            await (0, storage_1.setItem)(storage_1.StorageKeys.DEVICE_ID, config.deviceId);
+            if (this.debug)
+                console.log(`[BytemTracker] Using developer-set device ID: ${config.deviceId}`);
         }
-        if (config.debug) {
-            console.log('[BytemTracker] Initialized with config:', this.config);
-            console.log('[BytemTracker] Visitor ID:', this.visitorId);
+        else {
+            this.deviceIdType = 1; // Auto generated (using visitor ID or platform ID logic)
+        }
+        this.isInitialized = true;
+        if (this.debug) {
+            console.log('[BytemTracker] Initialized ✅');
+            console.log(`  app_key: ${this.appKey}`);
+            console.log(`  base_url: ${this.baseUrl}`);
+            console.log(`  visitor_id: ${this.visitorId}`);
+            if (this.appScheme)
+                console.log(`  app_scheme: ${this.appScheme}`);
+        }
+        // Begin session
+        try {
+            await this.beginSession();
+        }
+        catch (e) {
+            if (this.debug) {
+                console.warn('[BytemTracker] Failed to begin session during init:', e);
+            }
+            this.sessionStarted = false;
+        }
+    }
+    ensureInitialized() {
+        if (!this.isInitialized) {
+            throw new Error('[BytemTracker] Not initialized. Call await init() first.');
         }
     }
-    async track(payload) {
-        if (!this.isInitialized || !this.config || !this.visitorId) {
-            console.error('[BytemTracker] Not initialized. Call await init() first.');
+    async beginSession(force = false) {
+        this.ensureInitialized();
+        if (this.sessionStarted) {
+            if (this.debug)
+                console.log('[BytemTracker] Session already started, skipping');
             return;
         }
-        const baseParams = await (0, base_1.buildBaseRequestParams)(this.config.appId, this.visitorId);
-        const finalData = Object.assign(Object.assign({}, baseParams), payload);
-        if (this.config.debug) {
-            console.log('[BytemTracker] Tracking event:', finalData);
-        }
-        if (this.config.endpoint) {
-            let requestUrl = this.config.endpoint;
-            try {
-                const urlObj = new URL(this.config.endpoint);
-                const hasEndpointPath = urlObj.pathname && urlObj.pathname !== '/';
-                const pathToUse = this.config.path;
-                if (pathToUse) {
-                    urlObj.pathname = pathToUse.startsWith('/') ? pathToUse : '/' + pathToUse;
-                    requestUrl = urlObj.toString();
-                }
-                else if (!hasEndpointPath) {
-                    urlObj.pathname = '/i';
-                    requestUrl = urlObj.toString();
+        try {
+            this.sessionStarted = true;
+            this.lastBeat = Date.now();
+            // Check session cookie
+            const sessionKey = `${this.appKey}/cly_session`;
+            const expireTimestampStr = await (0, storage_1.getItem)(sessionKey);
+            const expireTimestamp = expireTimestampStr ? parseInt(expireTimestampStr, 10) : null;
+            const currentTimestamp = Date.now();
+            const shouldSendRequest = force ||
+                !this.useSessionCookie ||
+                expireTimestamp === null ||
+                expireTimestamp <= currentTimestamp;
+            if (!shouldSendRequest) {
+                if (this.debug)
+                    console.log('[BytemTracker] Session cookie still valid, skipping begin_session request');
+                // Update cookie
+                await (0, storage_1.setItem)(sessionKey, (currentTimestamp + this.sessionCookieTimeout * 60 * 1000).toString());
+                return;
+            }
+            const deviceId = await this.getRealDeviceId();
+            const metrics = await this.getMetrics();
+            const body = await this.buildBaseRequestParams(deviceId);
+            body['begin_session'] = '1';
+            body['metrics'] = JSON.stringify(metrics);
+            await this.sendRequest(this.apiPath, body, 'Begin Session');
+            await (0, storage_1.setItem)(sessionKey, (currentTimestamp + this.sessionCookieTimeout * 60 * 1000).toString());
+        }
+        catch (e) {
+            this.sessionStarted = false;
+            if (this.debug)
+                console.error('[BytemTracker] Error in beginSession:', e);
+        }
+    }
+    async sessionDuration(sec) {
+        this.ensureInitialized();
+        if (!this.sessionStarted) {
+            if (this.debug)
+                console.log('[BytemTracker] Session not started, skipping session_duration');
+            return;
+        }
+        const deviceId = await this.getRealDeviceId();
+        const body = await this.buildBaseRequestParams(deviceId);
+        body['session_duration'] = sec.toString();
+        await this.sendRequest(this.apiPath, body, 'Session Duration');
+        this.lastBeat = Date.now();
+        await this.extendSession();
+    }
+    async endSession(sec, force = false) {
+        this.ensureInitialized();
+        if (!this.sessionStarted) {
+            if (this.debug)
+                console.log('[BytemTracker] Session not started, skipping end_session');
+            return;
+        }
+        const currentTimestamp = Date.now();
+        const sessionSec = sec !== null && sec !== void 0 ? sec : (this.lastBeat ? (currentTimestamp - this.lastBeat) / 1000 : 0);
+        if (this.debug)
+            console.log(`[BytemTracker] Ending session with duration: ${sessionSec} seconds`);
+        if (this.useSessionCookie && !force) {
+            await this.sessionDuration(sessionSec);
+            this.sessionStarted = false;
+            return;
+        }
+        const deviceId = await this.getRealDeviceId();
+        const body = await this.buildBaseRequestParams(deviceId);
+        body['end_session'] = '1';
+        body['session_duration'] = sessionSec.toString();
+        await this.sendRequest(this.apiPath, body, 'End Session');
+        this.sessionStarted = false;
+    }
+    async trackSessions() {
+        this.ensureInitialized();
+        if (this.debug)
+            console.log('[BytemTracker] trackSessions called');
+        if (this.sessionStarted && this.lastBeat) {
+            const duration = (Date.now() - this.lastBeat) / 1000;
+            if (duration > 0) {
+                if (this.debug)
+                    console.log(`[BytemTracker] Session already started, sending session_duration: ${duration}s`);
+                await this.sessionDuration(duration);
+            }
+        }
+        else {
+            await this.beginSession();
+        }
+        this.startTime();
+        if (this.debug)
+            console.log('[BytemTracker] Session tracking started');
+    }
+    startTime() {
+        if (!this.trackTime) {
+            this.trackTime = true;
+            const now = Date.now();
+            if (this.lastBeat && this.storedDuration > 0) {
+                this.lastBeat = now - this.storedDuration;
+                this.storedDuration = 0;
+            }
+            else {
+                this.lastBeat = now;
+            }
+            if (this.lastViewStoredDuration > 0 && this.lastViewTime > 0) {
+                this.lastViewTime = now - this.lastViewStoredDuration;
+                this.lastViewStoredDuration = 0;
+            }
+            else {
+                this.lastViewTime = now;
+            }
+            if (this.debug)
+                console.log('[BytemTracker] Time tracking started');
+            this.extendSession();
+        }
+    }
+    stopTime() {
+        if (this.trackTime) {
+            this.trackTime = false;
+            const now = Date.now();
+            if (this.lastBeat) {
+                this.storedDuration = now - this.lastBeat;
+            }
+            if (this.lastViewTime > 0) {
+                this.lastViewStoredDuration = now - this.lastViewTime;
+            }
+            if (this.debug)
+                console.log('[BytemTracker] Time tracking stopped');
+        }
+    }
+    async trackEvent(eventKey, segmentation, count = 1, sum, duration) {
+        this.ensureInitialized();
+        const deviceId = await this.getRealDeviceId();
+        const now = new Date();
+        const event = {
+            key: eventKey,
+            count: count,
+            segmentation: segmentation,
+            timestamp: now.getTime(),
+            hour: now.getHours(),
+            dow: now.getDay() === 0 ? 0 : now.getDay(), // JS getDay: 0=Sun, Dart: 7=Sun but mapped to 0. 0-6.
+        };
+        if (sum !== undefined)
+            event.sum = sum;
+        if (duration !== undefined)
+            event.dur = duration;
+        const body = await this.buildBaseRequestParams(deviceId);
+        body['events'] = JSON.stringify([event]);
+        await this.sendRequest(this.apiPath, body, 'Event');
+    }
+    async trackPageview(current, referrer) {
+        await this.reportViewDuration();
+        const segmentation = {
+            name: current,
+            current: current,
+            referrer: '',
+        };
+        if (referrer)
+            segmentation.referrer = referrer;
+        let duration;
+        if (this.lastViewTime > 0) {
+            const now = Date.now();
+            duration = this.trackTime
+                ? (now - this.lastViewTime) / 1000
+                : this.lastViewStoredDuration / 1000;
+        }
+        this.lastViewTime = Date.now();
+        if (!this.trackTime) {
+            this.lastViewStoredDuration = 0;
+        }
+        await this.trackEvent(types_1.BytemEventKeys.view, segmentation, 1, undefined, duration);
+    }
+    async trackGoodsClick(params) {
+        this.ensureInitialized();
+        const segmentation = {
+            gid: params.gid || '',
+            skuid: params.skuid || '',
+            url: params.url,
+            current: params.current || '',
+            referrer: params.referrer || '',
+            visitor_id: this.visitorId || '',
+        };
+        if (this.appScheme)
+            segmentation.domain = this.appScheme;
+        if (params.source)
+            segmentation.source = params.source;
+        if (params.position)
+            segmentation.position = params.position;
+        await this.trackEvent('goods_click', segmentation); // Using string literal as Dart does in implementation
+    }
+    // --- Helpers ---
+    async reportViewDuration() {
+        if (this.lastViewTime === 0)
+            return;
+        const now = Date.now();
+        const duration = this.trackTime
+            ? (now - this.lastViewTime) / 1000
+            : this.lastViewStoredDuration / 1000;
+        if (duration > 0) {
+            if (this.debug)
+                console.log(`[BytemTracker] Last page duration: ${duration}s`);
+        }
+    }
+    async getRealDeviceId() {
+        // 1. Check developer set ID
+        if (this.deviceIdType === 0) {
+            const stored = await (0, storage_1.getItem)(storage_1.StorageKeys.DEVICE_ID);
+            if (stored)
+                return stored;
+        }
+        // 2. Use visitor ID
+        return this.visitorId || (0, device_1.generateUUID)();
+    }
+    async getMetrics() {
+        const metrics = {
+            _sdk_name: this.SDK_NAME,
+            _sdk_version: this.SDK_VERSION,
+        };
+        try {
+            const info = await (0, device_1.getDeviceInfo)();
+            metrics._platform_version = info.osVersion;
+            metrics._app_version = this.SDK_VERSION; // Or get actual app version if available
+            metrics._resolution = `${Math.round(info.screenWidth)}x${Math.round(info.screenHeight)}`;
+            metrics._locale = info.language;
+            // _density could be added if available in getDeviceInfo
+        }
+        catch (e) {
+            if (this.debug)
+                console.warn('[BytemTracker] Error getting metrics:', e);
+        }
+        return metrics;
+    }
+    async buildBaseRequestParams(deviceId) {
+        const now = new Date();
+        const visitorId = this.visitorId || (0, device_1.generateUUID)();
+        const params = {
+            app_key: this.appKey,
+            device_id: deviceId,
+            kid: visitorId,
+            visitor_id: visitorId,
+            sdk_name: this.SDK_NAME,
+            sdk_version: this.SDK_VERSION,
+            t: this.deviceIdType.toString(),
+            timestamp: now.getTime().toString(),
+            hour: now.getHours().toString(),
+            dow: (now.getDay() === 0 ? 0 : now.getDay()).toString(),
+        };
+        // Add location info if available (not implemented yet in this class properties)
+        return params;
+    }
+    async extendSession() {
+        if (!this.useSessionCookie)
+            return;
+        const sessionKey = `${this.appKey}/cly_session`;
+        const expireTimestampStr = await (0, storage_1.getItem)(sessionKey);
+        const currentTimestamp = Date.now();
+        const expireTimestamp = expireTimestampStr ? parseInt(expireTimestampStr, 10) : null;
+        if (expireTimestamp === null || expireTimestamp <= currentTimestamp) {
+            if (this.debug)
+                console.log('[BytemTracker] Session expired, restarting session');
+            this.sessionStarted = false;
+            await this.beginSession(true);
+        }
+        else {
+            await (0, storage_1.setItem)(sessionKey, (currentTimestamp + this.sessionCookieTimeout * 60 * 1000).toString());
+        }
+    }
+    async sendRequest(path, body, requestName) {
+        // Manually constructing URL and using fetch with urlencoded body
+        let requestUrl = this.baseUrl;
+        try {
+            // Handle endpoint/path logic
+            const urlObj = new URL(this.baseUrl);
+            if (path) {
+                if (path.startsWith('http')) {
+                    requestUrl = path;
                 }
                 else {
-                    requestUrl = this.config.endpoint;
+                    // If base url has path, append or replace?
+                    // Dart implementation just concatenates: "$_baseUrl$path"
+                    // But _baseUrl usually has no trailing slash, and path starts with /
+                    const base = this.baseUrl.endsWith('/') ? this.baseUrl.slice(0, -1) : this.baseUrl;
+                    const endpointPath = path.startsWith('/') ? path : '/' + path;
+                    requestUrl = `${base}${endpointPath}`;
                 }
             }
-            catch (_a) {
-                requestUrl = this.config.endpoint;
+        }
+        catch (e) {
+            requestUrl = this.baseUrl + path;
+        }
+        if (this.debug) {
+            console.log(`📤 [BytemTracker] Sending ${requestName}:`);
+            console.log(`  URL: ${requestUrl}`);
+            console.log(`  Body:`, body);
+        }
+        try {
+            // Convert body to urlencoded string
+            const formBody = Object.keys(body).map(key => encodeURIComponent(key) + '=' + encodeURIComponent(body[key])).join('&');
+            const response = await fetch(requestUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: formBody,
+            });
+            if (this.debug) {
+                const resText = await response.text();
+                console.log(`📥 [BytemTracker] Response (${response.status}): ${resText}`);
             }
-            await (0, request_1.sendRequest)(requestUrl, finalData);
+        }
+        catch (e) {
+            if (this.debug)
+                console.error(`❌ [BytemTracker] Error sending ${requestName}:`, e);
         }
     }
-    trackViewProduct(product) {
-        const payload = Business.trackViewProduct(product);
-        this.track(payload);
+    // Wrappers for Business methods to maintain compatibility or you can refactor them too
+    async trackViewProduct(product) {
+        // Map Product to segmentation
+        const segmentation = {
+            product_id: product.productId,
+            name: product.name,
+            price: product.price,
+            currency: product.currency,
+            category: product.category,
+        };
+        // In Dart, trackViewProduct sends "view_product" event.
+        await this.trackEvent('view_product', segmentation);
     }
-    trackCheckOutOrder(order) {
-        const payload = Business.trackCheckOutOrder(order);
-        this.track(payload);
+    async trackCheckOutOrder(order) {
+        // Map Order to segmentation
+        const segmentation = {
+            order_id: order.orderId,
+            total: order.total,
+            currency: order.currency,
+            // products need to be handled. Dart sends lists of gids, etc.
+            // This is a simplification. Ideally we replicate trackCheckOutOrder logic fully.
+        };
+        await this.trackEvent('check_out_order', segmentation);
+    }
+    async trackPayOrder(order) {
+        const segmentation = {
+            order_id: order.orderId,
+            total: order.total,
+            currency: order.currency,
+        };
+        await this.trackEvent('pay_order', segmentation);
     }
-    trackPayOrder(order) {
-        const payload = Business.trackPayOrder(order);
-        this.track(payload);
+    async trackUser(userId, traits) {
+        // Map to user_details
+        // This is a special request in Dart: "user_details" param
+        await this.sendUserDetails(userId, traits);
     }
-    trackUser(userId, traits) {
-        const payload = Business.trackUser(userId, traits);
-        this.track(payload);
+    async sendUserDetails(userId, traits) {
+        this.ensureInitialized();
+        const deviceId = await this.getRealDeviceId();
+        const userData = Object.assign({}, traits);
+        if (userId) {
+            userData.custom = Object.assign(Object.assign({}, userData.custom), { user_id: userId, visitor_id: this.visitorId });
+        }
+        const body = await this.buildBaseRequestParams(deviceId);
+        body['user_details'] = JSON.stringify(userData);
+        await this.sendRequest(this.apiPath, body, 'User Details');
     }
 }
 exports.default = BytemTracker.getInstance();

package/dist/src/types.d.ts

@@ -4,7 +4,18 @@ export interface TrackerConfig {
     path?: string;
     debug?: boolean;
     visitorId?: string;
+    deviceId?: string;
+    appScheme?: string;
 }
+export declare const BytemEventKeys: {
+    nps: string;
+    survey: string;
+    starRating: string;
+    view: string;
+    orientation: string;
+    pushAction: string;
+    action: string;
+};
 export interface DeviceInfo {
     platform: string;
     os: string;

package/dist/src/types.js

@@ -1,2 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BytemEventKeys = void 0;
+exports.BytemEventKeys = {
+    nps: "[CLY]_nps",
+    survey: "[CLY]_survey",
+    starRating: "[CLY]_star_rating",
+    view: "[CLY]_view",
+    orientation: "[CLY]_orientation",
+    pushAction: "[CLY]_push_action",
+    action: "[CLY]_action",
+};

package/dist/test/BytemTracker.test.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const BytemTracker_1 = __importDefault(require("../src/BytemTracker"));
 const storage_1 = require("../src/core/storage");
 const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const types_1 = require("../src/types");
 describe('BytemTracker SDK', () => {
     const mockConfig = {
         appId: 'test-app-id',
@@ -14,71 +15,234 @@ describe('BytemTracker SDK', () => {
     };
     beforeEach(() => {
         jest.clearAllMocks();
-        // Reset singleton instance manually
-        // @ts-ignore
-        BytemTracker_1.default.instance = undefined;
+        // Reset singleton instance state manually
         // @ts-ignore
         BytemTracker_1.default.isInitialized = false;
         // @ts-ignore
-        BytemTracker_1.default.config = null;
+        BytemTracker_1.default.appKey = null;
+        // @ts-ignore
+        BytemTracker_1.default.baseUrl = 'https://tracking.server.bytecon.com';
         // @ts-ignore
         BytemTracker_1.default.visitorId = null;
+        // @ts-ignore
+        BytemTracker_1.default.sessionStarted = false;
+        // @ts-ignore
+        BytemTracker_1.default.lastBeat = null;
+        // @ts-ignore
+        BytemTracker_1.default.trackTime = true;
+        // @ts-ignore
+        BytemTracker_1.default.storedDuration = 0;
+        // @ts-ignore
+        BytemTracker_1.default.lastViewTime = 0;
+        // @ts-ignore
+        BytemTracker_1.default.lastViewStoredDuration = 0;
+        // Clear storage mocks
+        // @ts-ignore
+        async_storage_1.default.clear();
     });
-    it('should initialize correctly', async () => {
-        await BytemTracker_1.default.init(mockConfig);
-        // Verify Storage was checked for Visitor ID
-        expect(async_storage_1.default.getItem).toHaveBeenCalledWith(storage_1.StorageKeys.VISITOR_ID);
-        // Verify Session was initialized (checks storage)
-        expect(async_storage_1.default.getItem).toHaveBeenCalledWith(storage_1.StorageKeys.SESSION_ID);
+    describe('Initialization', () => {
+        it('should initialize correctly', async () => {
+            await BytemTracker_1.default.init(mockConfig);
+            // Verify Storage was checked for Visitor ID
+            expect(async_storage_1.default.getItem).toHaveBeenCalledWith(storage_1.StorageKeys.VISITOR_ID);
+            // Verify Session was initialized (checks storage)
+            expect(async_storage_1.default.getItem).toHaveBeenCalledWith(`${mockConfig.appId}/cly_session`);
+        });
+        it('should use default endpoint when not provided', async () => {
+            await BytemTracker_1.default.init({
+                appId: 'test-app-id',
+                // endpoint is omitted
+                debug: true,
+            });
+            await BytemTracker_1.default.trackEvent('test_event', {});
+            expect(global.fetch).toHaveBeenCalled();
+            const calls = global.fetch.mock.calls;
+            // Check any call, they should all use the default endpoint
+            const url = calls[0][0];
+            expect(url).toBe('https://tracking.server.bytecon.com/i');
+        });
+        it('should override endpoint path when path is configured', async () => {
+            await BytemTracker_1.default.init({
+                appId: 'test-app-id-2',
+                endpoint: 'https://api.example.com/track',
+                path: '/collect',
+                debug: true,
+            });
+            await BytemTracker_1.default.trackEvent('test_event', {});
+            expect(global.fetch).toHaveBeenCalled();
+            const calls = global.fetch.mock.calls;
+            const url = calls[0][0];
+            expect(url).toBe('https://api.example.com/track/collect');
+        });
     });
-    it('should track an event', async () => {
-        // Ensure initialized (singleton persists)
-        await BytemTracker_1.default.init(mockConfig);
-        const eventName = 'test_event';
-        const eventParams = { foo: 'bar' };
-        // @ts-ignore - Accessing private method for testing or just use public track methods
-        // Since track is private, we'll use a public method like trackUser or just trust the public API
-        // Let's use trackUser as a proxy for generic tracking
-        BytemTracker_1.default.trackUser('user-123', { age: 25 });
-        // Wait for async operations if any (track is async but void return in public API might hide it)
-        // In BytemTracker.ts, trackUser calls track, which is async but not awaited by caller.
-        // We need to wait for promises to resolve.
-        await new Promise(resolve => setTimeout(resolve, 0));
-        expect(global.fetch).toHaveBeenCalledTimes(1);
-        const fetchCall = global.fetch.mock.calls[0];
-        const url = fetchCall[0];
-        const options = fetchCall[1];
-        expect(url).toBe(mockConfig.endpoint);
-        expect(options.method).toBe('POST');
-        const body = JSON.parse(options.body);
-        expect(body.app_id).toBe(mockConfig.appId);
-        // expect(body.event).toBe('identify'); 
+    describe('Event Tracking', () => {
+        beforeEach(async () => {
+            await BytemTracker_1.default.init(mockConfig);
+        });
+        it('should track a simple event', async () => {
+            const eventName = 'test_event';
+            const segmentation = { foo: 'bar' };
+            await BytemTracker_1.default.trackEvent(eventName, segmentation);
+            expect(global.fetch).toHaveBeenCalled();
+            const calls = global.fetch.mock.calls;
+            const eventCall = calls.find(call => call[1].body && call[1].body.includes('events='));
+            expect(eventCall).toBeDefined();
+            const options = eventCall[1];
+            const body = options.body;
+            expect(body).toContain(`app_key=${mockConfig.appId}`);
+            expect(body).toContain('events=%5B%7B%22key%22%3A%22test_event%22');
+        });
+        it('should track event with count and sum', async () => {
+            const eventName = 'purchase';
+            const count = 3;
+            const sum = 99.99;
+            const segmentation = { item: 'apple' };
+            await BytemTracker_1.default.trackEvent(eventName, segmentation, count, sum);
+            const calls = global.fetch.mock.calls;
+            const eventCall = calls.find(call => call[1].body && call[1].body.includes('events='));
+            const body = decodeURIComponent(eventCall[1].body);
+            const events = JSON.parse(new URLSearchParams(eventCall[1].body).get('events') || '[]');
+            expect(events[0]).toMatchObject({
+                key: eventName,
+                count: count,
+                sum: sum,
+                segmentation: segmentation
+            });
+        });
+        it('should track event with duration', async () => {
+            const eventName = 'video_watched';
+            const duration = 120; // seconds
+            await BytemTracker_1.default.trackEvent(eventName, {}, 1, undefined, duration);
+            const calls = global.fetch.mock.calls;
+            const eventCall = calls.find(call => call[1].body && call[1].body.includes('events='));
+            const events = JSON.parse(new URLSearchParams(eventCall[1].body).get('events') || '[]');
+            expect(events[0].dur).toBe(duration);
+        });
+    });
+    describe('Page View Tracking', () => {
+        beforeEach(async () => {
+            await BytemTracker_1.default.init(mockConfig);
+        });
+        it('should track page view', async () => {
+            const pageName = '/home';
+            await BytemTracker_1.default.trackPageview(pageName);
+            const calls = global.fetch.mock.calls;
+            const eventCall = calls.find(call => call[1].body && call[1].body.includes(`%22key%22%3A%22${encodeURIComponent(types_1.BytemEventKeys.view)}%22`));
+            expect(eventCall).toBeDefined();
+            const events = JSON.parse(new URLSearchParams(eventCall[1].body).get('events') || '[]');
+            expect(events[0].segmentation).toMatchObject({
+                name: pageName,
+                current: pageName,
+                referrer: ''
+            });
+        });
+        it('should track page view with referrer', async () => {
+            const pageName = '/product/123';
+            const referrer = '/home';
+            await BytemTracker_1.default.trackPageview(pageName, referrer);
+            const calls = global.fetch.mock.calls;
+            // Get the last call which should be the page view
+            const eventCall = calls[calls.length - 1];
+            const events = JSON.parse(new URLSearchParams(eventCall[1].body).get('events') || '[]');
+            expect(events[0].segmentation).toMatchObject({
+                name: pageName,
+                current: pageName,
+                referrer: referrer
+            });
+        });
+    });
+    describe('User Tracking', () => {
+        beforeEach(async () => {
+            await BytemTracker_1.default.init(mockConfig);
+        });
+        it('should track user details', async () => {
+            const userId = 'user_123';
+            const userTraits = {
+                name: 'John Doe',
+                email: 'john@example.com',
+                custom: {
+                    plan: 'premium'
+                }
+            };
+            await BytemTracker_1.default.trackUser(userId, userTraits);
+            const calls = global.fetch.mock.calls;
+            const userCall = calls.find(call => call[1].body && call[1].body.includes('user_details='));
+            expect(userCall).toBeDefined();
+            const userDetails = JSON.parse(new URLSearchParams(userCall[1].body).get('user_details') || '{}');
+            expect(userDetails).toMatchObject({
+                name: 'John Doe',
+                email: 'john@example.com',
+                custom: {
+                    plan: 'premium',
+                    user_id: userId
+                }
+            });
+        });
     });
-    it('should use default endpoint when not provided', async () => {
-        await BytemTracker_1.default.init({
-            appId: 'test-app-id',
-            // endpoint is omitted
-            debug: true,
-        });
-        BytemTracker_1.default.trackUser('user-123', { age: 25 });
-        await new Promise(resolve => setTimeout(resolve, 0));
-        expect(global.fetch).toHaveBeenCalledTimes(1);
-        const fetchCall = global.fetch.mock.calls[0];
-        const url = fetchCall[0];
-        expect(url).toBe('https://tracking.server.bytecon.com/i');
+    describe('Session Management', () => {
+        beforeEach(async () => {
+            await BytemTracker_1.default.init(mockConfig);
+        });
+        it('should track session start', async () => {
+            await BytemTracker_1.default.trackSessions();
+            const calls = global.fetch.mock.calls;
+            const sessionCall = calls.find(call => call[1].body && call[1].body.includes('begin_session=1'));
+            expect(sessionCall).toBeDefined();
+        });
+        it('should track session end', async () => {
+            // First start session
+            await BytemTracker_1.default.trackSessions();
+            // Then end session
+            await BytemTracker_1.default.endSession(undefined, true); // force=true to bypass cookie check for test
+            const calls = global.fetch.mock.calls;
+            const endSessionCall = calls.find(call => call[1].body && call[1].body.includes('end_session=1'));
+            expect(endSessionCall).toBeDefined();
+            const body = new URLSearchParams(endSessionCall[1].body);
+            expect(body.has('session_duration')).toBe(true);
+        });
     });
-    it('should override endpoint path when path is configured', async () => {
-        await BytemTracker_1.default.init({
-            appId: 'test-app-id-2',
-            endpoint: 'https://api.example.com/track',
-            path: '/collect',
-            debug: true,
-        });
-        BytemTracker_1.default.trackUser('user-456', { age: 30 });
-        await new Promise(resolve => setTimeout(resolve, 0));
-        expect(global.fetch).toHaveBeenCalledTimes(1);
-        const fetchCall = global.fetch.mock.calls[0];
-        const url = fetchCall[0];
-        expect(url).toBe('https://api.example.com/collect');
+    describe('E-commerce Tracking', () => {
+        beforeEach(async () => {
+            await BytemTracker_1.default.init(mockConfig);
+        });
+        it('should track checkout order', async () => {
+            const order = {
+                orderId: 'order_123',
+                total: 99.99,
+                currency: 'USD',
+                products: [
+                    { productId: 'prod_1', price: 50, quantity: 1 },
+                    { productId: 'prod_2', price: 49.99, quantity: 1 }
+                ]
+            };
+            await BytemTracker_1.default.trackCheckOutOrder(order);
+            const calls = global.fetch.mock.calls;
+            const eventCall = calls.find(call => call[1].body && call[1].body.includes('events='));
+            const events = JSON.parse(new URLSearchParams(eventCall[1].body).get('events') || '[]');
+            expect(events[0].key).toBe('check_out_order');
+            expect(events[0].segmentation).toMatchObject({
+                order_id: 'order_123',
+                total: 99.99,
+                currency: 'USD'
+            });
+        });
+        it('should track pay order', async () => {
+            const order = {
+                orderId: 'order_123',
+                total: 99.99,
+                currency: 'USD',
+                products: []
+            };
+            await BytemTracker_1.default.trackPayOrder(order);
+            const calls = global.fetch.mock.calls;
+            const eventCall = calls.find(call => call[1].body && call[1].body.includes('events='));
+            const events = JSON.parse(new URLSearchParams(eventCall[1].body).get('events') || '[]');
+            expect(events[0].key).toBe('pay_order');
+            expect(events[0].segmentation).toMatchObject({
+                order_id: 'order_123',
+                total: 99.99,
+                currency: 'USD'
+            });
+        });
     });
 });

package/dist/test/debug.test.js

@@ -13,7 +13,22 @@ describe('Debug Scenarios', () => {
     };
     beforeEach(async () => {
         jest.clearAllMocks();
+        // Reset singleton instance state manually
+        // @ts-ignore
+        BytemTracker_1.default.isInitialized = false;
+        // @ts-ignore
+        BytemTracker_1.default.appKey = null;
+        // @ts-ignore
+        BytemTracker_1.default.baseUrl = 'https://tracking.server.bytecon.com';
+        // @ts-ignore
+        BytemTracker_1.default.visitorId = null;
+        // @ts-ignore
+        BytemTracker_1.default.sessionStarted = false;
+        // @ts-ignore
+        BytemTracker_1.default.lastBeat = null;
         // Simulate fresh start
+        // @ts-ignore
+        async_storage_1.default.clear();
         async_storage_1.default.getItem.mockResolvedValue(null);
         await BytemTracker_1.default.init(mockConfig);
     });
@@ -48,11 +63,28 @@ describe('Debug Scenarios', () => {
         });
         await new Promise(resolve => setTimeout(resolve, 0));
         // Assertions to verify flow
-        expect(global.fetch).toHaveBeenCalledTimes(3);
+        // Expect 4 calls: begin_session, view_product, user_details, check_out_order
+        expect(global.fetch).toHaveBeenCalledTimes(4);
         const calls = global.fetch.mock.calls;
-        // Check Event Types
-        const events = calls.map((call) => JSON.parse(call[1].body).event);
-        console.log('>>> Captured Events:', events);
-        expect(events).toEqual(['view_product', 'identify', 'checkout_order']);
+        // Check Request Types
+        const requestTypes = calls.map((call) => {
+            const body = call[1].body;
+            if (body.includes('begin_session=1'))
+                return 'begin_session';
+            if (body.includes('user_details='))
+                return 'identify';
+            if (body.includes('events=')) {
+                // Extract event key
+                const match = body.match(/events=(.*?)($|&)/);
+                if (match) {
+                    const eventsJson = decodeURIComponent(match[1]);
+                    const events = JSON.parse(eventsJson);
+                    return events[0].key;
+                }
+            }
+            return 'unknown';
+        });
+        console.log('>>> Captured Requests:', requestTypes);
+        expect(requestTypes).toEqual(['begin_session', 'view_product', 'identify', 'check_out_order']);
     });
 });

package/dist/test/setup.js

@@ -53,4 +53,5 @@ global.fetch = jest.fn(() => Promise.resolve({
     status: 200,
     statusText: 'OK',
     json: () => Promise.resolve({}),
+    text: () => Promise.resolve('{"status":"success"}'),
 }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytem/bytem-tracker-app",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Bytem Tracker SDK for React Native",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",