@productbet/tracker-core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1148 @@
+const DEFAULT_OPTIONS = {
+    ingestionUrl: "https://productbet.io/tracking",
+    enableSessionRecording: false,
+    enableAutoTracking: true,
+    autoTrackingOptions: {
+        trackClicks: true,
+        trackForms: true,
+        trackNavigation: true,
+        trackScrollDepth: true,
+        detectRageClicks: true,
+        detectDeadClicks: true,
+        includeText: true,
+        includeClasses: true,
+    },
+    redaction: {
+        mode: "privacy-first",
+        unredactFields: [],
+    },
+    maxQueueSize: 1000,
+    flushIntervalMs: 3000,
+    enableConsoleTracking: true,
+    enableNetworkTracking: true,
+    recordCanvas: false,
+    sessionTimeoutMs: 30 * 60 * 1000,
+    debug: false,
+};
+const SDK_VERSION = "0.1.0";
+
+let debugEnabled = false;
+function setDebug(enabled) {
+    debugEnabled = enabled;
+}
+function debug(...args) {
+    if (debugEnabled) {
+        console.log("[ProductBet]", ...args);
+    }
+}
+function warn(...args) {
+    console.warn("[ProductBet]", ...args);
+}
+function error(...args) {
+    console.error("[ProductBet]", ...args);
+}
+
+const STORAGE_KEY = "pb_session";
+const WINDOW_ID_KEY = "pb_window_id";
+function generateId() {
+    const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+    const segments = [8, 4, 4, 12];
+    return segments
+        .map((len) => Array.from({ length: len }, () => chars[Math.floor(Math.random() * chars.length)]).join(""))
+        .join("-");
+}
+class SessionManager {
+    constructor(timeoutMs) {
+        this.timeoutMs = timeoutMs;
+        this.windowId = this.getOrCreateWindowId();
+        const restored = this.restore();
+        if (restored) {
+            this.sessionId = restored.sessionId;
+            this.startedAt = restored.startedAt;
+            this.lastActivityAt = restored.lastActivityAt;
+            debug("Restored session", this.sessionId);
+        }
+        else {
+            this.sessionId = generateId();
+            this.startedAt = Date.now();
+            this.lastActivityAt = Date.now();
+            this.persist();
+            debug("Created new session", this.sessionId);
+        }
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getWindowId() {
+        return this.windowId;
+    }
+    getStartedAt() {
+        return this.startedAt;
+    }
+    touch() {
+        this.lastActivityAt = Date.now();
+        this.persist();
+    }
+    isExpired() {
+        return Date.now() - this.lastActivityAt > this.timeoutMs;
+    }
+    rotate() {
+        this.sessionId = generateId();
+        this.startedAt = Date.now();
+        this.lastActivityAt = Date.now();
+        this.persist();
+        debug("Rotated session", this.sessionId);
+        return this.sessionId;
+    }
+    persist() {
+        try {
+            const data = {
+                sessionId: this.sessionId,
+                lastActivityAt: this.lastActivityAt,
+                startedAt: this.startedAt,
+            };
+            localStorage.setItem(STORAGE_KEY, JSON.stringify(data));
+        }
+        catch {
+            // localStorage may be unavailable (SSR, private browsing)
+        }
+    }
+    restore() {
+        try {
+            const raw = localStorage.getItem(STORAGE_KEY);
+            if (!raw)
+                return null;
+            const data = JSON.parse(raw);
+            if (Date.now() - data.lastActivityAt > this.timeoutMs) {
+                localStorage.removeItem(STORAGE_KEY);
+                return null;
+            }
+            return data;
+        }
+        catch {
+            return null;
+        }
+    }
+    getOrCreateWindowId() {
+        try {
+            let id = sessionStorage.getItem(WINDOW_ID_KEY);
+            if (!id) {
+                id = generateId();
+                sessionStorage.setItem(WINDOW_ID_KEY, id);
+            }
+            return id;
+        }
+        catch {
+            return generateId();
+        }
+    }
+}
+
+const MAX_PAYLOAD_BYTES = 1000000;
+const RETRY_DELAYS = [1000, 2000, 4000, 8000];
+const QUEUE_STORAGE_KEY = "pb_event_queue";
+const MIN_SESSION_DURATION_MS = 5000;
+class ApiClient {
+    constructor(apiKey, ingestionUrl, sessionId, maxQueueSize, flushIntervalMs, windowId) {
+        this.queue = [];
+        this.replayQueue = [];
+        this.flushTimer = null;
+        this.endUserId = null;
+        this.isFlushing = false;
+        this.monthlyLimitReached = false;
+        this.startedAt = Date.now();
+        this.sessionMatureEnough = false;
+        this.apiKey = apiKey;
+        this.ingestionUrl = ingestionUrl.replace(/\/$/, "");
+        this.sessionId = sessionId;
+        this.windowId = windowId;
+        this.maxQueueSize = maxQueueSize;
+        this.flushIntervalMs = flushIntervalMs;
+        this.restoreQueue();
+    }
+    start() {
+        this.flushTimer = setInterval(() => this.flush(), this.flushIntervalMs);
+        if (typeof window !== "undefined") {
+            window.addEventListener("beforeunload", () => this.onUnload());
+            document.addEventListener("visibilitychange", () => {
+                if (document.visibilityState === "hidden")
+                    this.onUnload();
+            });
+        }
+        debug("ApiClient started, flushing every", this.flushIntervalMs, "ms");
+    }
+    stop() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.flush();
+    }
+    updateSessionId(sessionId) {
+        this.sessionId = sessionId;
+    }
+    setEndUserId(userId) {
+        this.endUserId = userId;
+    }
+    enqueueEvent(event) {
+        if (this.monthlyLimitReached)
+            return;
+        this.queue.push(event);
+        if (this.queue.length >= this.maxQueueSize) {
+            this.flush();
+        }
+    }
+    enqueueReplayEvent(event) {
+        if (this.monthlyLimitReached)
+            return;
+        this.replayQueue.push(event);
+    }
+    async sendIdentify(payload) {
+        try {
+            await this.post("/identify", payload);
+            debug("Identify sent", payload.userId);
+        }
+        catch (err) {
+            error("Failed to send identify", err);
+        }
+    }
+    async sendCustomEvent(payload) {
+        try {
+            await this.post("/custom", payload);
+            debug("Custom event sent", payload.eventName);
+        }
+        catch (err) {
+            error("Failed to send custom event", err);
+        }
+    }
+    async flush() {
+        if (this.isFlushing)
+            return;
+        if (this.queue.length === 0 && this.replayQueue.length === 0)
+            return;
+        if (this.monthlyLimitReached)
+            return;
+        if (!this.sessionMatureEnough) {
+            if (Date.now() - this.startedAt < MIN_SESSION_DURATION_MS) {
+                debug("Session too short, buffering events");
+                return;
+            }
+            this.sessionMatureEnough = true;
+        }
+        this.isFlushing = true;
+        const events = this.queue.splice(0);
+        const replayEvents = this.replayQueue.splice(0);
+        const batch = {
+            sessionId: this.sessionId,
+            windowId: this.windowId,
+            events,
+            replayEvents: replayEvents.length > 0 ? replayEvents : undefined,
+            endUserId: this.endUserId,
+            sdkVersion: SDK_VERSION,
+            timestamp: Date.now(),
+        };
+        try {
+            const payload = JSON.stringify(batch);
+            if (payload.length > MAX_PAYLOAD_BYTES) {
+                await this.sendChunked(events, replayEvents);
+            }
+            else {
+                const response = await this.post("/events", batch);
+                if (response?.monthlyLimitReached) {
+                    this.monthlyLimitReached = true;
+                    warn("Monthly event limit reached. Tracking paused.");
+                }
+            }
+            this.clearPersistedQueue();
+            debug("Flushed", events.length, "events +", replayEvents.length, "replay events");
+        }
+        catch {
+            this.queue.unshift(...events);
+            this.replayQueue.unshift(...replayEvents);
+            this.persistQueue();
+            warn("Flush failed, events re-queued");
+        }
+        finally {
+            this.isFlushing = false;
+        }
+    }
+    async sendChunked(events, replayEvents) {
+        const chunkSize = Math.ceil(events.length / 2);
+        for (let i = 0; i < events.length; i += chunkSize) {
+            const chunk = events.slice(i, i + chunkSize);
+            const replayChunk = i === 0 ? replayEvents : [];
+            const batch = {
+                sessionId: this.sessionId,
+                windowId: this.windowId,
+                events: chunk,
+                replayEvents: replayChunk.length > 0 ? replayChunk : undefined,
+                endUserId: this.endUserId,
+                sdkVersion: SDK_VERSION,
+                timestamp: Date.now(),
+            };
+            await this.post("/events", batch);
+        }
+    }
+    async post(path, body, retryCount = 0) {
+        const url = `${this.ingestionUrl}${path}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify(body),
+            credentials: "omit",
+        });
+        if (response.status === 429) {
+            this.monthlyLimitReached = true;
+            warn("Rate limited (429). Tracking paused.");
+            return { success: false, monthlyLimitReached: true };
+        }
+        if (response.status === 413 && retryCount === 0) {
+            warn("Payload too large, will chunk on next flush");
+            return null;
+        }
+        if (!response.ok) {
+            let errorBody = "";
+            try {
+                errorBody = await response.text();
+            }
+            catch { }
+            warn(`Ingestion error ${response.status}: ${errorBody}`);
+            if (retryCount < RETRY_DELAYS.length) {
+                const delay = RETRY_DELAYS[retryCount];
+                debug("Retrying in", delay, "ms (attempt", retryCount + 1, ")");
+                await new Promise((r) => setTimeout(r, delay));
+                return this.post(path, body, retryCount + 1);
+            }
+            throw new Error(`Ingestion failed: ${response.status}`);
+        }
+        return response.json();
+    }
+    onUnload() {
+        if (this.queue.length === 0 && this.replayQueue.length === 0)
+            return;
+        const batch = {
+            sessionId: this.sessionId,
+            windowId: this.windowId,
+            events: this.queue.splice(0),
+            replayEvents: this.replayQueue.length > 0
+                ? this.replayQueue.splice(0)
+                : undefined,
+            endUserId: this.endUserId,
+            sdkVersion: SDK_VERSION,
+            timestamp: Date.now(),
+        };
+        const url = `${this.ingestionUrl}/events`;
+        const payload = JSON.stringify(batch);
+        if (typeof navigator.sendBeacon === "function") {
+            const blob = new Blob([payload], { type: "application/json" });
+            const sent = navigator.sendBeacon(url, blob);
+            if (sent) {
+                debug("Sent via sendBeacon on unload");
+                return;
+            }
+        }
+        this.persistQueue();
+    }
+    persistQueue() {
+        try {
+            if (this.queue.length > 0) {
+                localStorage.setItem(QUEUE_STORAGE_KEY, JSON.stringify(this.queue));
+            }
+        }
+        catch {
+            // localStorage unavailable
+        }
+    }
+    restoreQueue() {
+        try {
+            const raw = localStorage.getItem(QUEUE_STORAGE_KEY);
+            if (raw) {
+                const events = JSON.parse(raw);
+                this.queue.unshift(...events);
+                localStorage.removeItem(QUEUE_STORAGE_KEY);
+                debug("Restored", events.length, "queued events");
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    clearPersistedQueue() {
+        try {
+            localStorage.removeItem(QUEUE_STORAGE_KEY);
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+
+const RAGE_CLICK_THRESHOLD = 3;
+const RAGE_CLICK_WINDOW_MS = 1000;
+const RAGE_CLICK_RADIUS_PX = 30;
+const DEAD_CLICK_TIMEOUT_MS = 2500;
+const INTERACTIVE_TAGS = new Set([
+    "A", "BUTTON", "INPUT", "SELECT", "TEXTAREA", "LABEL",
+]);
+const INTERACTIVE_ROLES = new Set([
+    "button", "link", "tab", "menuitem", "checkbox", "radio",
+]);
+function isInteractiveElement(el) {
+    let current = el;
+    while (current && current !== document.body) {
+        if (INTERACTIVE_TAGS.has(current.tagName))
+            return true;
+        const role = current.getAttribute("role");
+        if (role && INTERACTIVE_ROLES.has(role))
+            return true;
+        if (current.hasAttribute("onclick"))
+            return true;
+        if (current.hasAttribute("tabindex"))
+            return true;
+        current = current.parentElement;
+    }
+    try {
+        if (window.getComputedStyle(el).cursor === "pointer")
+            return true;
+    }
+    catch {
+        // getComputedStyle can throw on detached elements
+    }
+    return false;
+}
+class AutoTracker {
+    constructor(options, redaction, sessionId, onEvent) {
+        this.recentClicks = [];
+        this.scrollDepthMax = 0;
+        this.scrollTimer = null;
+        this.originalPushState = null;
+        this.originalReplaceState = null;
+        this.cleanupFns = [];
+        this.options = options;
+        this.redaction = redaction;
+        this.sessionId = sessionId;
+        this.onEvent = onEvent;
+    }
+    start() {
+        if (typeof window === "undefined")
+            return;
+        if (this.options.trackClicks !== false)
+            this.setupClickTracking();
+        if (this.options.trackForms !== false)
+            this.setupFormTracking();
+        if (this.options.trackNavigation !== false)
+            this.setupNavigationTracking();
+        if (this.options.trackScrollDepth !== false)
+            this.setupScrollTracking();
+        debug("AutoTracker started");
+    }
+    stop() {
+        this.cleanupFns.forEach((fn) => fn());
+        this.cleanupFns = [];
+        if (this.originalPushState) {
+            history.pushState = this.originalPushState;
+        }
+        if (this.originalReplaceState) {
+            history.replaceState = this.originalReplaceState;
+        }
+        debug("AutoTracker stopped");
+    }
+    updateSessionId(sessionId) {
+        this.sessionId = sessionId;
+    }
+    setupClickTracking() {
+        const handler = (e) => {
+            const target = e.target;
+            if (!target)
+                return;
+            const info = this.getElementInfo(target);
+            this.emit("click", {
+                element: info,
+                x: e.clientX,
+                y: e.clientY,
+                pageUrl: window.location.href,
+            });
+            if (this.options.detectRageClicks !== false) {
+                this.checkRageClick(e);
+            }
+            if (this.options.detectDeadClicks !== false) {
+                this.checkDeadClick(e, target);
+            }
+        };
+        document.addEventListener("click", handler, true);
+        this.cleanupFns.push(() => document.removeEventListener("click", handler, true));
+    }
+    setupFormTracking() {
+        const submitHandler = (e) => {
+            const form = e.target;
+            if (!form)
+                return;
+            this.emit("form_submit", {
+                element: this.getElementInfo(form),
+                action: form.action,
+                method: form.method,
+                pageUrl: window.location.href,
+            });
+        };
+        const changeHandler = (e) => {
+            const target = e.target;
+            if (!target)
+                return;
+            if (!["INPUT", "SELECT", "TEXTAREA"].includes(target.tagName))
+                return;
+            const info = this.getElementInfo(target);
+            this.emit("form_change", {
+                element: info,
+                fieldType: target.type || target.tagName.toLowerCase(),
+                pageUrl: window.location.href,
+            });
+        };
+        document.addEventListener("submit", submitHandler, true);
+        document.addEventListener("change", changeHandler, true);
+        this.cleanupFns.push(() => document.removeEventListener("submit", submitHandler, true), () => document.removeEventListener("change", changeHandler, true));
+    }
+    setupNavigationTracking() {
+        this.emitPageView();
+        const popstateHandler = () => this.emitPageView();
+        window.addEventListener("popstate", popstateHandler);
+        this.cleanupFns.push(() => window.removeEventListener("popstate", popstateHandler));
+        this.originalPushState = history.pushState.bind(history);
+        this.originalReplaceState = history.replaceState.bind(history);
+        history.pushState = (...args) => {
+            this.originalPushState(...args);
+            this.emitPageView();
+        };
+        history.replaceState = (...args) => {
+            this.originalReplaceState(...args);
+            this.emitPageView();
+        };
+    }
+    setupScrollTracking() {
+        const handler = () => {
+            if (this.scrollTimer)
+                clearTimeout(this.scrollTimer);
+            this.scrollTimer = setTimeout(() => {
+                const scrollHeight = document.documentElement.scrollHeight;
+                const viewportHeight = window.innerHeight;
+                const scrollTop = window.scrollY;
+                if (scrollHeight <= viewportHeight)
+                    return;
+                const depth = Math.round(((scrollTop + viewportHeight) / scrollHeight) * 100);
+                if (depth > this.scrollDepthMax) {
+                    this.scrollDepthMax = depth;
+                    this.emit("scroll_depth", {
+                        depth,
+                        pageUrl: window.location.href,
+                    });
+                }
+            }, 250);
+        };
+        window.addEventListener("scroll", handler, { passive: true });
+        this.cleanupFns.push(() => window.removeEventListener("scroll", handler));
+    }
+    checkRageClick(e) {
+        const now = Date.now();
+        this.recentClicks.push({
+            target: e.target,
+            timestamp: now,
+            x: e.clientX,
+            y: e.clientY,
+        });
+        this.recentClicks = this.recentClicks.filter((c) => now - c.timestamp < RAGE_CLICK_WINDOW_MS);
+        if (this.recentClicks.length >= RAGE_CLICK_THRESHOLD) {
+            const nearby = this.recentClicks.filter((c) => {
+                const dx = Math.abs(c.x - e.clientX);
+                const dy = Math.abs(c.y - e.clientY);
+                return dx <= RAGE_CLICK_RADIUS_PX && dy <= RAGE_CLICK_RADIUS_PX;
+            });
+            if (nearby.length >= RAGE_CLICK_THRESHOLD) {
+                const target = e.target;
+                this.emit("rage_click", {
+                    element: this.getElementInfo(target),
+                    clickCount: nearby.length,
+                    windowMs: RAGE_CLICK_WINDOW_MS,
+                    pageUrl: window.location.href,
+                });
+                this.recentClicks = [];
+            }
+        }
+    }
+    checkDeadClick(_e, target) {
+        if (isInteractiveElement(target))
+            return;
+        const clickUrl = window.location.href;
+        let hadMutation = false;
+        let hadScroll = false;
+        let hadSelection = false;
+        const observer = new MutationObserver(() => {
+            hadMutation = true;
+        });
+        observer.observe(document.body, {
+            childList: true,
+            subtree: true,
+            attributes: true,
+            characterData: true,
+        });
+        const scrollHandler = () => { hadScroll = true; };
+        const selectionHandler = () => {
+            const sel = window.getSelection();
+            if (sel && sel.toString().length > 0)
+                hadSelection = true;
+        };
+        window.addEventListener("scroll", scrollHandler, { passive: true, capture: true });
+        document.addEventListener("selectionchange", selectionHandler);
+        setTimeout(() => {
+            observer.disconnect();
+            window.removeEventListener("scroll", scrollHandler, true);
+            document.removeEventListener("selectionchange", selectionHandler);
+            const urlChanged = window.location.href !== clickUrl;
+            if (!hadMutation && !hadScroll && !hadSelection && !urlChanged) {
+                const reportTarget = this.findReportableAncestor(target) ?? target;
+                this.emit("dead_click", {
+                    element: this.getElementInfo(reportTarget),
+                    pageUrl: clickUrl,
+                });
+            }
+        }, DEAD_CLICK_TIMEOUT_MS);
+    }
+    findReportableAncestor(el) {
+        let current = el.parentElement;
+        while (current && current !== document.body) {
+            if (INTERACTIVE_TAGS.has(current.tagName))
+                return current;
+            if (current.getAttribute("role") === "button")
+                return current;
+            current = current.parentElement;
+        }
+        return null;
+    }
+    emitPageView() {
+        this.scrollDepthMax = 0;
+        this.emit("page_view", {
+            url: window.location.href,
+            path: window.location.pathname,
+            referrer: document.referrer,
+            title: document.title,
+        });
+    }
+    emit(type, data) {
+        this.onEvent({
+            type,
+            timestamp: Date.now(),
+            data,
+            sessionId: this.sessionId,
+        });
+    }
+    getElementInfo(el) {
+        const info = {
+            tag: el.tagName.toLowerCase(),
+            selector: this.buildSelector(el),
+        };
+        if (el.id)
+            info.id = el.id;
+        if (this.options.includeClasses !== false && el.className) {
+            const classes = typeof el.className === "string"
+                ? el.className.split(/\s+/).filter(Boolean)
+                : [];
+            if (classes.length > 0)
+                info.classes = classes;
+        }
+        if (this.options.includeText !== false) {
+            const isSensitiveInput = ["INPUT", "TEXTAREA", "SELECT"].includes(el.tagName);
+            if (!isSensitiveInput || this.redaction.mode !== "privacy-first") {
+                const text = el.textContent?.trim().slice(0, 100);
+                if (text)
+                    info.text = text;
+            }
+        }
+        if (el.tagName === "A") {
+            info.href = el.href;
+        }
+        if ("name" in el && typeof el.name === "string") {
+            info.name = el.name;
+        }
+        if ("type" in el && typeof el.type === "string") {
+            info.type = el.type;
+        }
+        return info;
+    }
+    buildSelector(el) {
+        if (el.id)
+            return `#${el.id}`;
+        const parts = [];
+        let current = el;
+        for (let i = 0; i < 4 && current && current !== document.body; i++) {
+            let part = current.tagName.toLowerCase();
+            if (current.id) {
+                part = `#${current.id}`;
+                parts.unshift(part);
+                break;
+            }
+            if (current.className && typeof current.className === "string") {
+                const cls = current.className
+                    .split(/\s+/)
+                    .filter(Boolean)
+                    .slice(0, 2)
+                    .join(".");
+                if (cls)
+                    part += `.${cls}`;
+            }
+            parts.unshift(part);
+            current = current.parentElement;
+        }
+        return parts.join(" > ");
+    }
+}
+
+class SessionRecorder {
+    constructor(redaction, recordCanvas, onEvent) {
+        this.recording = false;
+        this.stopFn = null;
+        this.redaction = redaction;
+        this.recordCanvas = recordCanvas;
+        this.onEvent = onEvent;
+    }
+    async start() {
+        if (this.recording)
+            return;
+        if (typeof window === "undefined")
+            return;
+        try {
+            const { record } = await import('rrweb');
+            const maskConfig = this.buildMaskConfig();
+            const stopFn = record({
+                emit: (event) => {
+                    this.onEvent(event);
+                },
+                ...maskConfig,
+                recordCanvas: this.recordCanvas,
+                sampling: {
+                    mousemove: true,
+                    mouseInteraction: true,
+                    scroll: 150,
+                    input: "last",
+                },
+                recordCrossOriginIframes: false,
+            });
+            if (stopFn)
+                this.stopFn = stopFn;
+            this.recording = true;
+            debug("Session recording started");
+        }
+        catch (err) {
+            warn("Failed to start rrweb recording:", err);
+        }
+    }
+    stop() {
+        if (this.stopFn) {
+            this.stopFn();
+            this.stopFn = null;
+        }
+        this.recording = false;
+        debug("Session recording stopped");
+    }
+    isRecording() {
+        return this.recording;
+    }
+    buildMaskConfig() {
+        if (this.redaction.mode === "privacy-first") {
+            return {
+                maskAllInputs: true,
+                maskTextSelector: "*",
+                maskInputOptions: {
+                    password: true,
+                    email: true,
+                    text: true,
+                    tel: true,
+                    url: true,
+                    search: true,
+                    number: true,
+                    textarea: true,
+                    select: true,
+                },
+                ...(this.redaction.unredactFields?.length
+                    ? {
+                        unmaskTextSelector: this.redaction.unredactFields
+                            .map((f) => `[data-pb-unmask="${f}"]`)
+                            .join(", "),
+                    }
+                    : {}),
+            };
+        }
+        return {
+            maskAllInputs: false,
+            maskInputOptions: {
+                password: true,
+            },
+        };
+    }
+}
+
+class ConsoleTracker {
+    constructor(sessionId, onEvent) {
+        this.originalWarn = null;
+        this.originalError = null;
+        this.sessionId = sessionId;
+        this.onEvent = onEvent;
+    }
+    start() {
+        if (typeof window === "undefined")
+            return;
+        this.originalWarn = console.warn;
+        this.originalError = console.error;
+        console.warn = (...args) => {
+            this.originalWarn?.apply(console, args);
+            this.trackConsole("console_warn", args);
+        };
+        console.error = (...args) => {
+            this.originalError?.apply(console, args);
+            this.trackConsole("console_error", args);
+        };
+        window.addEventListener("error", (e) => {
+            this.onEvent({
+                type: "console_error",
+                timestamp: Date.now(),
+                data: {
+                    message: e.message,
+                    filename: e.filename,
+                    lineno: e.lineno,
+                    colno: e.colno,
+                    stack: e.error?.stack,
+                },
+                sessionId: this.sessionId,
+            });
+        });
+        window.addEventListener("unhandledrejection", (e) => {
+            this.onEvent({
+                type: "console_error",
+                timestamp: Date.now(),
+                data: {
+                    message: String(e.reason),
+                    stack: e.reason?.stack,
+                    source: "unhandledrejection",
+                },
+                sessionId: this.sessionId,
+            });
+        });
+        debug("ConsoleTracker started");
+    }
+    stop() {
+        if (this.originalWarn)
+            console.warn = this.originalWarn;
+        if (this.originalError)
+            console.error = this.originalError;
+    }
+    updateSessionId(sessionId) {
+        this.sessionId = sessionId;
+    }
+    trackConsole(type, args) {
+        const message = args
+            .map((a) => {
+            if (typeof a === "string")
+                return a;
+            try {
+                return JSON.stringify(a);
+            }
+            catch {
+                return String(a);
+            }
+        })
+            .join(" ");
+        if (message.includes("[ProductBet]"))
+            return;
+        this.onEvent({
+            type,
+            timestamp: Date.now(),
+            data: {
+                message: message.slice(0, 2000),
+                url: window.location.href,
+            },
+            sessionId: this.sessionId,
+        });
+    }
+}
+
+class NetworkTracker {
+    constructor(sessionId, ingestionUrl, onEvent) {
+        this.originalFetch = null;
+        this.sessionId = sessionId;
+        this.ingestionUrl = ingestionUrl;
+        this.onEvent = onEvent;
+    }
+    start() {
+        if (typeof window === "undefined")
+            return;
+        if (this.originalFetch)
+            return;
+        this.originalFetch = window.fetch.bind(window);
+        const tracker = this;
+        window.fetch = function pbTrackedFetch(input, init) {
+            const url = typeof input === "string"
+                ? input
+                : input instanceof URL
+                    ? input.href
+                    : input.url;
+            if (url.startsWith(tracker.ingestionUrl)) {
+                return tracker.originalFetch(input, init);
+            }
+            const method = init?.method || "GET";
+            const startTime = Date.now();
+            return tracker.originalFetch(input, init).then((response) => {
+                if (response.status >= 400) {
+                    tracker.onEvent({
+                        type: "network_error",
+                        timestamp: Date.now(),
+                        data: {
+                            url: url.slice(0, 500),
+                            method,
+                            status: response.status,
+                            statusText: response.statusText,
+                            duration: Date.now() - startTime,
+                            errorType: response.status >= 500
+                                ? "server_error"
+                                : "client_error",
+                        },
+                        sessionId: tracker.sessionId,
+                    });
+                }
+                return response;
+            }, (err) => {
+                tracker.onEvent({
+                    type: "network_error",
+                    timestamp: Date.now(),
+                    data: {
+                        url: url.slice(0, 500),
+                        method,
+                        status: null,
+                        duration: Date.now() - startTime,
+                        errorType: "network_error",
+                        errorMessage: err instanceof Error ? err.message : String(err),
+                    },
+                    sessionId: tracker.sessionId,
+                });
+                throw err;
+            });
+        };
+        debug("NetworkTracker started");
+    }
+    stop() {
+        if (this.originalFetch) {
+            window.fetch = this.originalFetch;
+            this.originalFetch = null;
+        }
+    }
+    updateSessionId(sessionId) {
+        this.sessionId = sessionId;
+    }
+}
+
+let globalInstance = null;
+const IDLE_THRESHOLD_MS = 5 * 60000;
+const USER_ACTIVITY_EVENTS = ["click", "keydown", "scroll", "mousemove"];
+class ProductBetTracker {
+    constructor(apiKey, options = {}) {
+        this.autoTracker = null;
+        this.recorder = null;
+        this.consoleTracker = null;
+        this.networkTracker = null;
+        this.started = false;
+        this.activityCheckTimer = null;
+        this.lastActivityAt = Date.now();
+        this.idle = false;
+        this.apiKey = apiKey;
+        this.options = this.mergeOptions(options);
+        setDebug(this.options.debug);
+        this.session = new SessionManager(this.options.sessionTimeoutMs);
+        this.apiClient = new ApiClient(this.apiKey, this.options.ingestionUrl, this.session.getSessionId(), this.options.maxQueueSize, this.options.flushIntervalMs, this.session.getWindowId());
+        if (this.options.enableAutoTracking) {
+            this.autoTracker = new AutoTracker(this.options.autoTrackingOptions, this.options.redaction, this.session.getSessionId(), (event) => this.handleEvent(event));
+        }
+        if (this.options.enableSessionRecording) {
+            this.recorder = new SessionRecorder(this.options.redaction, this.options.recordCanvas, (event) => this.apiClient.enqueueReplayEvent(event));
+        }
+        if (this.options.enableConsoleTracking) {
+            this.consoleTracker = new ConsoleTracker(this.session.getSessionId(), (event) => this.handleEvent(event));
+        }
+        if (this.options.enableNetworkTracking) {
+            this.networkTracker = new NetworkTracker(this.session.getSessionId(), this.options.ingestionUrl, (event) => this.handleEvent(event));
+        }
+        debug("ProductBetTracker initialized");
+    }
+    static init(apiKey, options) {
+        if (!apiKey) {
+            throw new Error("ProductBet: apiKey is required");
+        }
+        if (globalInstance) {
+            warn("ProductBetTracker already initialized. Returning existing instance.");
+            return globalInstance;
+        }
+        globalInstance = new ProductBetTracker(apiKey, options);
+        return globalInstance;
+    }
+    static getInstance() {
+        return globalInstance;
+    }
+    start() {
+        if (this.started)
+            return;
+        if (typeof window === "undefined") {
+            warn("ProductBetTracker.start() called in non-browser environment. Skipping.");
+            return;
+        }
+        this.started = true;
+        this.apiClient.start();
+        this.autoTracker?.start();
+        this.recorder?.start();
+        this.consoleTracker?.start();
+        this.networkTracker?.start();
+        this.handleEvent({
+            type: "session_start",
+            timestamp: Date.now(),
+            data: {
+                url: window.location.href,
+                referrer: document.referrer,
+                screenWidth: window.screen.width,
+                screenHeight: window.screen.height,
+                viewportWidth: window.innerWidth,
+                viewportHeight: window.innerHeight,
+                userAgent: navigator.userAgent,
+                language: navigator.language,
+                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            },
+            sessionId: this.session.getSessionId(),
+        });
+        this.activityCheckTimer = setInterval(() => {
+            if (this.session.isExpired()) {
+                this.rotateSession();
+            }
+            this.checkIdle();
+        }, 60000);
+        this.setupActivityListeners();
+        debug("ProductBetTracker started");
+    }
+    stop() {
+        if (!this.started)
+            return;
+        this.handleEvent({
+            type: "session_end",
+            timestamp: Date.now(),
+            data: {},
+            sessionId: this.session.getSessionId(),
+        });
+        this.autoTracker?.stop();
+        this.recorder?.stop();
+        this.consoleTracker?.stop();
+        this.networkTracker?.stop();
+        this.apiClient.stop();
+        if (this.activityCheckTimer) {
+            clearInterval(this.activityCheckTimer);
+            this.activityCheckTimer = null;
+        }
+        this.started = false;
+        debug("ProductBetTracker stopped");
+    }
+    identify(userId, attributes) {
+        const props = { userId, attributes };
+        this.apiClient.setEndUserId(userId);
+        this.apiClient.sendIdentify({
+            userId: props.userId,
+            attributes: props.attributes || {},
+            sessionId: this.session.getSessionId(),
+        });
+        debug("User identified", userId);
+    }
+    track(eventName, properties) {
+        this.apiClient.sendCustomEvent({
+            sessionId: this.session.getSessionId(),
+            eventName,
+            eventProperties: properties || {},
+            endUserId: null,
+        });
+    }
+    getSessionId() {
+        return this.session.getSessionId();
+    }
+    setUnredactedFields(fields) {
+        this.options.redaction.unredactFields = fields;
+    }
+    getUnredactedFields() {
+        return this.options.redaction.unredactFields || [];
+    }
+    handleEvent(event) {
+        const isUserAction = event.type === "click" ||
+            event.type === "rage_click" ||
+            event.type === "form_submit" ||
+            event.type === "form_change" ||
+            event.type === "page_view" ||
+            event.type === "session_start" ||
+            event.type === "session_end";
+        if (isUserAction) {
+            this.lastActivityAt = Date.now();
+            if (this.idle) {
+                this.idle = false;
+                debug("User returned from idle");
+            }
+        }
+        if (this.idle && !isUserAction)
+            return;
+        this.session.touch();
+        this.apiClient.enqueueEvent(event);
+    }
+    setupActivityListeners() {
+        const onActivity = () => {
+            this.lastActivityAt = Date.now();
+            if (this.idle) {
+                this.idle = false;
+                debug("User returned from idle");
+            }
+        };
+        for (const evt of USER_ACTIVITY_EVENTS) {
+            window.addEventListener(evt, onActivity, { passive: true, capture: true });
+        }
+    }
+    checkIdle() {
+        if (this.idle)
+            return;
+        if (Date.now() - this.lastActivityAt > IDLE_THRESHOLD_MS) {
+            this.idle = true;
+            debug("User idle, pausing background event capture");
+        }
+    }
+    rotateSession() {
+        const newSessionId = this.session.rotate();
+        this.apiClient.updateSessionId(newSessionId);
+        this.autoTracker?.updateSessionId(newSessionId);
+        this.consoleTracker?.updateSessionId(newSessionId);
+        this.networkTracker?.updateSessionId(newSessionId);
+        debug("Session rotated to", newSessionId);
+        this.handleEvent({
+            type: "session_start",
+            timestamp: Date.now(),
+            data: {
+                url: window.location.href,
+                rotated: true,
+            },
+            sessionId: newSessionId,
+        });
+    }
+    mergeOptions(partial) {
+        return {
+            ...DEFAULT_OPTIONS,
+            ...partial,
+            autoTrackingOptions: {
+                ...DEFAULT_OPTIONS.autoTrackingOptions,
+                ...partial.autoTrackingOptions,
+            },
+            redaction: {
+                ...DEFAULT_OPTIONS.redaction,
+                ...partial.redaction,
+            },
+        };
+    }
+}
+
+export { ProductBetTracker, SDK_VERSION };
+//# sourceMappingURL=index.mjs.map