@bytem/bytem-tracker-app 0.0.3 → 0.0.7

package/dist/src/business/trackPayOrder.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackPayOrder = void 0;
+const trackPayOrder = (order) => {
+    return {
+        event: 'pay_order',
+        params: {
+            order_id: order.orderId,
+            total: order.total,
+            currency: order.currency,
+            products: order.products.map((p) => ({
+                product_id: p.productId,
+                name: p.name,
+                price: p.price,
+                quantity: p.quantity,
+            })),
+            status: 'success',
+        },
+    };
+};
+exports.trackPayOrder = trackPayOrder;

package/dist/src/business/trackUser.d.ts

@@ -0,0 +1,2 @@
+import { EventPayload, UserTraits } from '../types';
+export declare const trackUser: (userId: string, traits?: UserTraits) => EventPayload;

package/dist/src/business/trackUser.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackUser = void 0;
+const trackUser = (userId, traits = {}) => {
+    return {
+        event: 'identify',
+        params: {
+            user_id: userId,
+            traits: traits,
+        },
+    };
+};
+exports.trackUser = trackUser;

package/dist/src/business/trackViewProduct.d.ts

@@ -0,0 +1,2 @@
+import { EventPayload, Product } from '../types';
+export declare const trackViewProduct: (product: Product) => EventPayload;

package/dist/src/business/trackViewProduct.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackViewProduct = void 0;
+const trackViewProduct = (product) => {
+    return {
+        event: 'view_product',
+        params: {
+            product_id: product.productId,
+            name: product.name,
+            price: product.price,
+            currency: product.currency,
+            category: product.category,
+        },
+    };
+};
+exports.trackViewProduct = trackViewProduct;

package/dist/src/core/base.d.ts

@@ -0,0 +1,2 @@
+import { BaseParams } from '../types';
+export declare const buildBaseRequestParams: (appId: string, visitorId: string) => Promise<BaseParams>;

package/dist/src/core/base.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBaseRequestParams = void 0;
+const device_1 = require("./device");
+const session_1 = require("./session");
+const buildBaseRequestParams = async (appId, visitorId) => {
+    const deviceInfo = await (0, device_1.getDeviceInfo)();
+    const sessionInfo = (0, session_1.getSessionInfo)();
+    return {
+        app_id: appId,
+        device_id: visitorId,
+        session_id: sessionInfo ? sessionInfo.sessionId : '',
+        timestamp: Date.now(),
+        platform: deviceInfo.platform,
+        os: deviceInfo.os,
+        os_version: deviceInfo.osVersion,
+        model: deviceInfo.model,
+        language: deviceInfo.language,
+        screen_width: deviceInfo.screenWidth,
+        screen_height: deviceInfo.screenHeight,
+        user_agent: deviceInfo.userAgent,
+    };
+};
+exports.buildBaseRequestParams = buildBaseRequestParams;

package/dist/src/core/device.d.ts

@@ -0,0 +1,3 @@
+import { DeviceInfo } from '../types';
+export declare const getDeviceInfo: () => Promise<DeviceInfo>;
+export declare const generateUUID: () => string;

package/dist/src/core/device.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUUID = exports.getDeviceInfo = void 0;
+const react_native_1 = require("react-native");
+const react_native_device_info_1 = __importDefault(require("react-native-device-info"));
+const getDeviceInfo = async () => {
+    var _a, _b, _c;
+    const os = react_native_device_info_1.default.getSystemName();
+    const osVersion = react_native_device_info_1.default.getSystemVersion();
+    const model = react_native_device_info_1.default.getModel();
+    const userAgent = await react_native_device_info_1.default.getUserAgent();
+    // Try to get language
+    let language = 'en';
+    if (react_native_1.Platform.OS === 'ios') {
+        const settings = (_a = react_native_1.NativeModules.SettingsManager) === null || _a === void 0 ? void 0 : _a.settings;
+        language = (settings === null || settings === void 0 ? void 0 : settings.AppleLocale) || ((_b = settings === null || settings === void 0 ? void 0 : settings.AppleLanguages) === null || _b === void 0 ? void 0 : _b[0]) || 'en';
+    }
+    else if (react_native_1.Platform.OS === 'android') {
+        language = ((_c = react_native_1.NativeModules.I18nManager) === null || _c === void 0 ? void 0 : _c.localeIdentifier) || 'en';
+    }
+    const { width, height } = react_native_1.Dimensions.get('window');
+    return {
+        platform: react_native_1.Platform.OS,
+        os,
+        osVersion,
+        model,
+        screenWidth: width,
+        screenHeight: height,
+        language,
+        userAgent,
+    };
+};
+exports.getDeviceInfo = getDeviceInfo;
+const generateUUID = () => {
+    // Simple UUID v4 generator that doesn't require crypto polyfills
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+};
+exports.generateUUID = generateUUID;

package/dist/src/core/request.d.ts

@@ -0,0 +1,2 @@
+import { EventPayload } from '../types';
+export declare const sendRequest: (endpoint: string, data: EventPayload) => Promise<void>;

package/dist/src/core/request.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendRequest = void 0;
+const sendRequest = async (endpoint, data) => {
+    try {
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(data),
+        });
+        if (!response.ok) {
+            console.error(`[BytemTracker] Request failed: ${response.statusText}`);
+        }
+    }
+    catch (error) {
+        console.error('[BytemTracker] Network error:', error);
+    }
+};
+exports.sendRequest = sendRequest;

package/dist/src/core/session.d.ts

@@ -0,0 +1,17 @@
+import { SessionInfo } from '../types';
+/**
+ * Initialize session. Must be called before tracking events.
+ * 1. Checks memory (fastest)
+ * 2. Checks storage
+ * 3. Creates new if none exists
+ */
+export declare const initSession: () => Promise<SessionInfo>;
+/**
+ * Force start a new session
+ */
+export declare const refreshSession: () => Promise<SessionInfo>;
+/**
+ * Get current session info.
+ * WARNING: Returns null if initSession() hasn't been called/awaited.
+ */
+export declare const getSessionInfo: () => SessionInfo | null;

package/dist/src/core/session.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionInfo = exports.refreshSession = exports.initSession = void 0;
+const device_1 = require("./device");
+const storage_1 = require("./storage");
+let currentSession = null;
+/**
+ * Initialize session. Must be called before tracking events.
+ * 1. Checks memory (fastest)
+ * 2. Checks storage
+ * 3. Creates new if none exists
+ */
+const initSession = async () => {
+    if (currentSession) {
+        return currentSession;
+    }
+    try {
+        const storedId = await (0, storage_1.getItem)(storage_1.StorageKeys.SESSION_ID);
+        const storedStart = await (0, storage_1.getItem)(storage_1.StorageKeys.SESSION_START);
+        if (storedId && storedStart) {
+            currentSession = {
+                sessionId: storedId,
+                startTime: parseInt(storedStart, 10),
+            };
+        }
+        else {
+            await (0, exports.refreshSession)();
+        }
+    }
+    catch (e) {
+        // If error, generate new
+        await (0, exports.refreshSession)();
+    }
+    return currentSession;
+};
+exports.initSession = initSession;
+/**
+ * Force start a new session
+ */
+const refreshSession = async () => {
+    const newId = (0, device_1.generateUUID)();
+    const newStart = Date.now();
+    currentSession = {
+        sessionId: newId,
+        startTime: newStart,
+    };
+    await (0, storage_1.setItem)(storage_1.StorageKeys.SESSION_ID, newId);
+    await (0, storage_1.setItem)(storage_1.StorageKeys.SESSION_START, newStart.toString());
+    return currentSession;
+};
+exports.refreshSession = refreshSession;
+/**
+ * Get current session info.
+ * WARNING: Returns null if initSession() hasn't been called/awaited.
+ */
+const getSessionInfo = () => {
+    return currentSession;
+};
+exports.getSessionInfo = getSessionInfo;

package/dist/src/core/storage.d.ts

@@ -0,0 +1,9 @@
+export declare const StorageKeys: {
+    VISITOR_ID: string;
+    DEVICE_ID: string;
+    SESSION_ID: string;
+    SESSION_START: string;
+};
+export declare const getItem: (key: string) => Promise<string | null>;
+export declare const setItem: (key: string, value: string) => Promise<void>;
+export declare const removeItem: (key: string) => Promise<void>;

package/dist/src/core/storage.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeItem = exports.setItem = exports.getItem = exports.StorageKeys = void 0;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+exports.StorageKeys = {
+    VISITOR_ID: 'bytem_visitor_id',
+    DEVICE_ID: 'bytem_device_id',
+    SESSION_ID: 'bytem_session_id',
+    SESSION_START: 'bytem_session_start',
+};
+const getItem = async (key) => {
+    try {
+        return await async_storage_1.default.getItem(key);
+    }
+    catch (e) {
+        console.warn('[BytemTracker] Storage get error:', e);
+        return null;
+    }
+};
+exports.getItem = getItem;
+const setItem = async (key, value) => {
+    try {
+        await async_storage_1.default.setItem(key, value);
+    }
+    catch (e) {
+        console.warn('[BytemTracker] Storage set error:', e);
+    }
+};
+exports.setItem = setItem;
+const removeItem = async (key) => {
+    try {
+        await async_storage_1.default.removeItem(key);
+    }
+    catch (e) {
+        console.warn('[BytemTracker] Storage remove error:', e);
+    }
+};
+exports.removeItem = removeItem;

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+import BytemTracker from './BytemTracker';
+export * from './types';
+export default BytemTracker;

package/dist/src/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BytemTracker_1 = __importDefault(require("./BytemTracker"));
+__exportStar(require("./types"), exports);
+exports.default = BytemTracker_1.default;

package/dist/src/types.d.ts

@@ -0,0 +1,67 @@
+export interface TrackerConfig {
+    appId: string;
+    endpoint?: string;
+    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;
+    osVersion: string;
+    model: string;
+    screenWidth: number;
+    screenHeight: number;
+    language: string;
+    userAgent: string;
+}
+export interface SessionInfo {
+    sessionId: string;
+    startTime: number;
+}
+export interface BaseParams {
+    app_id: string;
+    device_id: string;
+    session_id: string;
+    timestamp: number;
+    platform: string;
+    os: string;
+    os_version: string;
+    model: string;
+    language: string;
+    screen_width: number;
+    screen_height: number;
+    user_agent: string;
+}
+export interface UserTraits {
+    [key: string]: any;
+}
+export interface Product {
+    productId: string;
+    name?: string;
+    price?: number;
+    currency?: string;
+    category?: string;
+    quantity?: number;
+}
+export interface Order {
+    orderId: string;
+    total: number;
+    currency: string;
+    products: Product[];
+}
+export interface EventPayload {
+    event: string;
+    params: Record<string, any>;
+}

package/dist/src/types.js

@@ -0,0 +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.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/BytemTracker.test.js

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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',
+        endpoint: 'https://api.example.com/track',
+        debug: true,
+    };
+    beforeEach(() => {
+        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;
+        // @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();
+    });
+    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');
+        });
+    });
+    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
+                }
+            });
+        });
+    });
+    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);
+        });
+    });
+    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.d.ts

@@ -0,0 +1 @@
+export {};