@bytem/bytem-tracker-app 0.0.6 → 0.0.8

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) {
@@ -52,84 +35,540 @@ class BytemTracker {
         }
         return BytemTracker.instance;
     }
+    /**
+     * Initializes the BytemTracker SDK with the provided configuration.
+     * This method must be called before any other tracking methods.
+     *
+     * @param config - The configuration object for the tracker.
+     * @returns A promise that resolves when initialization is complete.
+     */
     async init(config) {
         if (this.isInitialized) {
             console.warn('[BytemTracker] Already initialized');
             return;
         }
-        this.config = config;
-        this.isInitialized = true;
-        // Initialize Visitor ID
+        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 logic:
+        // 1. If provided in config, use it.
+        // 2. If not, try to retrieve from storage.
+        // 3. If not in storage, generate a new UUID.
         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 logic:
+        // 0: Developer supplied
+        // 1: SDK generated (default)
+        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}`);
+        }
+        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}`);
+        }
+        // Attempt to begin a session automatically on init
+        try {
+            await this.beginSession();
         }
-        if (config.debug) {
-            console.log('[BytemTracker] Initialized with config:', this.config);
-            console.log('[BytemTracker] Visitor ID:', this.visitorId);
+        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.');
+    /**
+     * Begins a new user session.
+     * Handles session cookie logic to prevent excessive session starts if one is already active.
+     *
+     * @param force - If true, forces a new session start request even if the session cookie is valid.
+     */
+    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 to avoid duplicate session starts
+            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');
+                // Extend the cookie validity
+                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);
+        }
+    }
+    /**
+     * Reports session duration to the server.
+     * Usually called internally or when app state changes.
+     *
+     * @param sec - The duration in seconds to report.
+     */
+    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();
+    }
+    /**
+     * Ends the current user session.
+     *
+     * @param sec - Optional duration of the session in seconds. If not provided, it's calculated from the last beat.
+     * @param force - If true, forces the end session request even if using session cookies.
+     */
+    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;
+    }
+    /**
+     * Manually tracks or extends a session.
+     * If a session is active, it reports duration. If not, it begins a new session.
+     */
+    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');
+    }
+    /**
+     * Resumes time tracking for session duration.
+     */
+    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();
+        }
+    }
+    /**
+     * Pauses time tracking for session duration.
+     */
+    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');
+        }
+    }
+    /**
+     * Tracks a custom event.
+     *
+     * @param eventKey - The unique key/name for the event.
+     * @param segmentation - Optional key-value pairs to attach to the event.
+     * @param count - The number of times this event occurred (default: 1).
+     * @param sum - Optional numeric value associated with the event (e.g., purchase amount).
+     * @param duration - Optional duration associated with the event.
+     */
+    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');
+    }
+    /**
+     * Tracks a page view.
+     * Automatically handles reporting the duration of the previous page view.
+     *
+     * @param current - The name or path of the current page.
+     * @param referrer - Optional name or path of the previous page.
+     */
+    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);
+    }
+    /**
+     * Tracks a click on a product/goods item.
+     *
+     * @param params - The parameters for the goods click event.
+     */
+    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
+    /**
+     * Tracks a product view event.
+     * Maps the product details to a 'view_product' event.
+     *
+     * @param product - The product object to track.
+     */
+    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);
+    /**
+     * Tracks a checkout order event.
+     * Automatically splits product lists into parallel arrays (gids, prices, quantities)
+     * to match the backend requirement.
+     *
+     * @param order - The order object containing products to checkout.
+     */
+    async trackCheckOutOrder(order) {
+        // Map Order to segmentation
+        const segmentation = {
+            order_id: order.orderId,
+            total: order.total,
+            currency: order.currency,
+        };
+        if (order.products && order.products.length > 0) {
+            segmentation.gids = order.products.map(p => p.productId);
+            segmentation.prices = order.products.map(p => p.price);
+            segmentation.quantity = order.products.map(p => p.quantity || 1);
+            // Optional: skuids if available in Product type, currently not in interface but good to handle if extended
+            // segmentation.skuids = ... 
+        }
+        await this.trackEvent('check_out_order', segmentation);
     }
-    trackPayOrder(order) {
-        const payload = Business.trackPayOrder(order);
-        this.track(payload);
+    /**
+     * Tracks a payment order event.
+     * Maps product list to a 'goods' array structure expected by the backend.
+     *
+     * @param order - The order object that was paid for.
+     */
+    async trackPayOrder(order) {
+        const segmentation = {
+            order_id: order.orderId,
+            total: order.total,
+            currency: order.currency,
+        };
+        if (order.products && order.products.length > 0) {
+            // Dart maps this to a list of maps called "goods"
+            segmentation.goods = order.products.map(p => ({
+                gid: p.productId,
+                name: p.name,
+                price: p.price,
+                quantity: p.quantity || 1,
+            }));
+        }
+        await this.trackEvent('pay_order', segmentation);
     }
-    trackUser(userId, traits) {
-        const payload = Business.trackUser(userId, traits);
-        this.track(payload);
+    /**
+     * Tracks user details/profile updates.
+     *
+     * @param userId - The unique identifier for the user.
+     * @param traits - Additional user properties (email, name, custom fields).
+     */
+    async trackUser(userId, traits) {
+        // Map to user_details
+        // This is a special request in Dart: "user_details" param
+        await this.sendUserDetails(userId, traits);
+    }
+    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();