@bugspotter/sdk 0.1.0-alpha.1

package/dist/capture/console.d.ts

@@ -0,0 +1,29 @@
+import { BaseCapture, type CaptureOptions } from './base-capture';
+type ConsoleLevel = 'log' | 'warn' | 'error' | 'info' | 'debug';
+export interface ConsoleCaptureOptions extends CaptureOptions {
+    maxLogs?: number;
+    captureStackTrace?: boolean;
+    levels?: readonly ConsoleLevel[];
+}
+export declare class ConsoleCapture extends BaseCapture<LogEntry[], ConsoleCaptureOptions> {
+    private buffer;
+    private captureStackTrace;
+    private originalMethods;
+    constructor(options?: ConsoleCaptureOptions);
+    capture(): LogEntry[];
+    private formatMessage;
+    private createLogEntry;
+    private captureStack;
+    private addLog;
+    private interceptConsole;
+    getLogs(): LogEntry[];
+    clear(): void;
+    destroy(): void;
+}
+export interface LogEntry {
+    level: ConsoleLevel;
+    message: string;
+    timestamp: number;
+    stack?: string;
+}
+export {};

package/dist/capture/console.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleCapture = void 0;
+const base_capture_1 = require("./base-capture");
+const circular_buffer_1 = require("../core/circular-buffer");
+const CONSOLE_METHODS = ['log', 'warn', 'error', 'info', 'debug'];
+class ConsoleCapture extends base_capture_1.BaseCapture {
+    constructor(options = {}) {
+        var _a, _b, _c;
+        super(options);
+        this.originalMethods = new Map();
+        const maxLogs = (_a = options.maxLogs) !== null && _a !== void 0 ? _a : 100;
+        this.buffer = new circular_buffer_1.CircularBuffer(maxLogs);
+        this.captureStackTrace = (_b = options.captureStackTrace) !== null && _b !== void 0 ? _b : true;
+        this.interceptConsole((_c = options.levels) !== null && _c !== void 0 ? _c : CONSOLE_METHODS);
+    }
+    capture() {
+        return this.getLogs();
+    }
+    formatMessage(args) {
+        if (!args || args.length === 0) {
+            return '';
+        }
+        // Sanitize args if sanitizer is enabled
+        const sanitizedArgs = this.sanitizer ? this.sanitizer.sanitizeConsoleArgs(args) : args;
+        return sanitizedArgs
+            .map((arg) => {
+            var _a;
+            if (arg === null) {
+                return 'null';
+            }
+            if (arg === undefined) {
+                return 'undefined';
+            }
+            if (typeof arg === 'object') {
+                try {
+                    return JSON.stringify(arg);
+                }
+                catch (_b) {
+                    return `[${((_a = arg.constructor) === null || _a === void 0 ? void 0 : _a.name) || 'Object'}]`;
+                }
+            }
+            return String(arg);
+        })
+            .join(' ');
+    }
+    createLogEntry(method, args) {
+        const log = {
+            level: method,
+            message: this.formatMessage(args),
+            timestamp: Date.now(),
+        };
+        if (this.captureStackTrace && method === 'error') {
+            const stack = this.captureStack();
+            log.stack = this.sanitizer && stack ? this.sanitizer.sanitize(stack) : stack;
+        }
+        return log;
+    }
+    captureStack() {
+        const stack = new Error().stack;
+        // Remove first 3 lines (Error, captureStack, createLogEntry)
+        return stack === null || stack === void 0 ? void 0 : stack.split('\n').slice(3).join('\n');
+    }
+    addLog(log) {
+        this.buffer.add(log);
+    }
+    interceptConsole(levels = CONSOLE_METHODS) {
+        levels.forEach((method) => {
+            try {
+                const original = console[method];
+                this.originalMethods.set(method, original);
+                console[method] = (...args) => {
+                    try {
+                        const log = this.createLogEntry(method, args);
+                        this.addLog(log);
+                    }
+                    catch (error) {
+                        this.handleError('creating log entry', error);
+                    }
+                    original.apply(console, args);
+                };
+            }
+            catch (error) {
+                this.handleError(`intercepting console.${method}`, error);
+            }
+        });
+    }
+    getLogs() {
+        return this.buffer.getAll();
+    }
+    clear() {
+        this.buffer.clear();
+    }
+    destroy() {
+        try {
+            this.originalMethods.forEach((original, method) => {
+                const consoleMethod = method;
+                console[consoleMethod] = original;
+            });
+            this.originalMethods.clear();
+        }
+        catch (error) {
+            this.handleError('destroying console capture', error);
+        }
+    }
+}
+exports.ConsoleCapture = ConsoleCapture;

package/dist/capture/metadata.d.ts

@@ -0,0 +1,21 @@
+import { BaseCapture, type CaptureOptions } from './base-capture';
+export interface BrowserMetadata {
+    userAgent: string;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    browser: string;
+    os: string;
+    url: string;
+    timestamp: number;
+}
+export type MetadataCaptureOptions = CaptureOptions;
+export declare class MetadataCapture extends BaseCapture<BrowserMetadata, MetadataCaptureOptions> {
+    private readonly browserPatterns;
+    private readonly osPatterns;
+    constructor(options?: MetadataCaptureOptions);
+    capture(): BrowserMetadata;
+    private detectBrowser;
+    private detectOS;
+}

package/dist/capture/metadata.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataCapture = void 0;
+const base_capture_1 = require("./base-capture");
+class MetadataCapture extends base_capture_1.BaseCapture {
+    constructor(options = {}) {
+        super(options);
+        this.browserPatterns = [
+            { pattern: 'Edg', name: 'Edge' }, // Check Edge before Chrome
+            { pattern: 'Chrome', exclude: 'Edge', name: 'Chrome' },
+            { pattern: 'Firefox', name: 'Firefox' },
+            { pattern: 'Safari', exclude: 'Chrome', name: 'Safari' },
+        ];
+        this.osPatterns = [
+            { patterns: ['iPhone', 'iPad'], name: 'iOS' }, // Check iOS before Mac
+            { patterns: ['Android'], name: 'Android' }, // Check Android before Linux
+            { patterns: ['Win'], name: 'Windows' },
+            { patterns: ['Mac'], name: 'macOS' },
+            { patterns: ['Linux'], name: 'Linux' },
+        ];
+    }
+    capture() {
+        try {
+            const metadata = {
+                userAgent: navigator.userAgent,
+                viewport: {
+                    width: window.innerWidth,
+                    height: window.innerHeight,
+                },
+                browser: this.detectBrowser(),
+                os: this.detectOS(),
+                url: window.location.href,
+                timestamp: Date.now(),
+            };
+            // Sanitize sensitive data if sanitizer is enabled
+            if (this.sanitizer) {
+                metadata.url = this.sanitizer.sanitize(metadata.url);
+                metadata.userAgent = this.sanitizer.sanitize(metadata.userAgent);
+            }
+            return metadata;
+        }
+        catch (error) {
+            this.handleError('capturing metadata', error);
+            // Return fallback metadata
+            return {
+                userAgent: 'Unknown',
+                viewport: { width: 0, height: 0 },
+                browser: 'Unknown',
+                os: 'Unknown',
+                url: 'Unknown',
+                timestamp: Date.now(),
+            };
+        }
+    }
+    detectBrowser() {
+        const ua = navigator.userAgent;
+        for (const { pattern, exclude, name } of this.browserPatterns) {
+            if (ua.includes(pattern) && (!exclude || !ua.includes(exclude))) {
+                return name;
+            }
+        }
+        return 'Unknown';
+    }
+    detectOS() {
+        const ua = navigator.userAgent;
+        for (const { patterns, name } of this.osPatterns) {
+            if (patterns.some((pattern) => {
+                return ua.includes(pattern);
+            })) {
+                return name;
+            }
+        }
+        return 'Unknown';
+    }
+}
+exports.MetadataCapture = MetadataCapture;

package/dist/capture/network.d.ts

@@ -0,0 +1,32 @@
+import { BaseCapture, type CaptureOptions } from './base-capture';
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+export interface NetworkCaptureOptions extends CaptureOptions {
+    maxRequests?: number;
+    filterUrls?: (url: string) => boolean;
+}
+export declare class NetworkCapture extends BaseCapture<NetworkRequest[], NetworkCaptureOptions> {
+    private buffer;
+    private filterUrls?;
+    private originalFetch;
+    private originalXHR;
+    private isIntercepting;
+    constructor(options?: NetworkCaptureOptions);
+    capture(): NetworkRequest[];
+    private parseFetchArgs;
+    private createNetworkRequest;
+    private addRequest;
+    private interceptFetch;
+    private interceptXHR;
+    getRequests(): NetworkRequest[];
+    clear(): void;
+    destroy(): void;
+}
+export interface NetworkRequest {
+    url: string;
+    method: HttpMethod;
+    status: number;
+    duration: number;
+    timestamp: number;
+    error?: string;
+}
+export {};

package/dist/capture/network.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkCapture = void 0;
+const base_capture_1 = require("./base-capture");
+const circular_buffer_1 = require("../core/circular-buffer");
+class NetworkCapture extends base_capture_1.BaseCapture {
+    constructor(options = {}) {
+        var _a;
+        super(options);
+        this.isIntercepting = false;
+        const maxRequests = (_a = options.maxRequests) !== null && _a !== void 0 ? _a : 50;
+        this.buffer = new circular_buffer_1.CircularBuffer(maxRequests);
+        this.filterUrls = options.filterUrls;
+        this.originalFetch = window.fetch;
+        this.originalXHR = {
+            open: XMLHttpRequest.prototype.open,
+            send: XMLHttpRequest.prototype.send,
+        };
+        this.interceptFetch();
+        this.interceptXHR();
+        this.isIntercepting = true;
+    }
+    capture() {
+        return this.getRequests();
+    }
+    parseFetchArgs(args) {
+        const [input, init] = args;
+        let url;
+        let method = 'GET';
+        if (typeof input === 'string') {
+            url = input;
+        }
+        else if (input instanceof Request) {
+            url = input.url;
+            method = input.method.toUpperCase() || 'GET';
+        }
+        else {
+            url = input.toString();
+        }
+        if (init === null || init === void 0 ? void 0 : init.method) {
+            method = init.method.toUpperCase();
+        }
+        return { url, method };
+    }
+    createNetworkRequest(url, method, status, startTime, error) {
+        const request = Object.assign({ url,
+            method,
+            status, duration: Date.now() - startTime, timestamp: startTime }, (error && { error }));
+        // Sanitize network data if sanitizer is enabled
+        if (this.sanitizer) {
+            const sanitized = this.sanitizer.sanitizeNetworkData(Object.assign({ url: request.url, method: request.method, status: request.status }, (request.error && { error: request.error })));
+            return Object.assign(Object.assign({}, request), { url: sanitized.url || request.url, error: sanitized.error });
+        }
+        return request;
+    }
+    addRequest(request) {
+        if (this.filterUrls && !this.filterUrls(request.url)) {
+            return; // Skip filtered URLs
+        }
+        this.buffer.add(request);
+    }
+    interceptFetch() {
+        const originalFetch = this.originalFetch;
+        window.fetch = async (...args) => {
+            const startTime = Date.now();
+            let url = '';
+            let method = 'GET';
+            try {
+                ({ url, method } = this.parseFetchArgs(args));
+            }
+            catch (error) {
+                this.handleError('parsing fetch arguments', error);
+            }
+            try {
+                const response = await originalFetch(...args);
+                const request = this.createNetworkRequest(url, method, response.status, startTime);
+                this.addRequest(request);
+                return response;
+            }
+            catch (error) {
+                const request = this.createNetworkRequest(url, method, 0, startTime, error.message);
+                this.addRequest(request);
+                throw error;
+            }
+        };
+    }
+    interceptXHR() {
+        const originalOpen = this.originalXHR.open;
+        const originalSend = this.originalXHR.send;
+        const createRequest = this.createNetworkRequest.bind(this);
+        const addRequest = this.addRequest.bind(this);
+        XMLHttpRequest.prototype.open = function (method, url, ...args) {
+            this._method = method.toUpperCase();
+            this._url = url.toString();
+            this._startTime = Date.now();
+            // Type assertion needed for rest params compatibility
+            return originalOpen.apply(this, [method, url, ...args]);
+        };
+        XMLHttpRequest.prototype.send = function (...args) {
+            const onLoad = () => {
+                const request = createRequest(this._url || '', this._method || 'GET', this.status, this._startTime || Date.now());
+                addRequest(request);
+            };
+            const onError = () => {
+                const request = createRequest(this._url || '', this._method || 'GET', 0, this._startTime || Date.now(), 'XMLHttpRequest failed');
+                addRequest(request);
+            };
+            this.addEventListener('load', onLoad);
+            this.addEventListener('error', onError);
+            // Type assertion needed for rest params compatibility
+            return originalSend.apply(this, args);
+        };
+    }
+    getRequests() {
+        return this.buffer.getAll();
+    }
+    clear() {
+        this.buffer.clear();
+    }
+    destroy() {
+        if (!this.isIntercepting) {
+            return;
+        }
+        try {
+            window.fetch = this.originalFetch;
+            XMLHttpRequest.prototype.open = this.originalXHR.open;
+            XMLHttpRequest.prototype.send = this.originalXHR.send;
+            this.isIntercepting = false;
+        }
+        catch (error) {
+            this.handleError('destroying network capture', error);
+        }
+    }
+}
+exports.NetworkCapture = NetworkCapture;

package/dist/capture/screenshot.d.ts

@@ -0,0 +1,19 @@
+import { BaseCapture, type CaptureOptions } from './base-capture';
+export interface ScreenshotCaptureOptions extends CaptureOptions {
+    quality?: number;
+    pixelRatio?: number;
+    backgroundColor?: string;
+    cacheBust?: boolean;
+    targetElement?: HTMLElement;
+    excludeAttribute?: string;
+    width?: number;
+    height?: number;
+    errorPlaceholder?: string;
+}
+export declare class ScreenshotCapture extends BaseCapture<Promise<string>, ScreenshotCaptureOptions> {
+    constructor(options?: ScreenshotCaptureOptions);
+    protected getErrorPlaceholder(): string;
+    private shouldIncludeNode;
+    private buildCaptureOptions;
+    capture(targetElement?: HTMLElement): Promise<string>;
+}

package/dist/capture/screenshot.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScreenshotCapture = void 0;
+const html_to_image_1 = require("html-to-image");
+const base_capture_1 = require("./base-capture");
+const compress_1 = require("../core/compress");
+const DEFAULT_SCREENSHOT_OPTIONS = {
+    quality: 0.8,
+    cacheBust: true,
+    backgroundColor: '#ffffff',
+    excludeAttribute: 'data-bugspotter-exclude',
+    errorPlaceholder: 'SCREENSHOT_FAILED',
+};
+class ScreenshotCapture extends base_capture_1.BaseCapture {
+    constructor(options = {}) {
+        super(options);
+    }
+    getErrorPlaceholder() {
+        var _a;
+        return (_a = this.options.errorPlaceholder) !== null && _a !== void 0 ? _a : DEFAULT_SCREENSHOT_OPTIONS.errorPlaceholder;
+    }
+    shouldIncludeNode(node) {
+        if (!('hasAttribute' in node)) {
+            return true;
+        }
+        const element = node;
+        const excludeAttr = this.options.excludeAttribute || DEFAULT_SCREENSHOT_OPTIONS.excludeAttribute;
+        return !element.hasAttribute(excludeAttr);
+    }
+    buildCaptureOptions() {
+        var _a, _b, _c, _d;
+        return Object.assign(Object.assign(Object.assign({ quality: (_a = this.options.quality) !== null && _a !== void 0 ? _a : DEFAULT_SCREENSHOT_OPTIONS.quality, cacheBust: (_b = this.options.cacheBust) !== null && _b !== void 0 ? _b : DEFAULT_SCREENSHOT_OPTIONS.cacheBust, pixelRatio: (_c = this.options.pixelRatio) !== null && _c !== void 0 ? _c : window.devicePixelRatio, backgroundColor: (_d = this.options.backgroundColor) !== null && _d !== void 0 ? _d : DEFAULT_SCREENSHOT_OPTIONS.backgroundColor }, (this.options.width && { width: this.options.width })), (this.options.height && { height: this.options.height })), { filter: (node) => {
+                return this.shouldIncludeNode(node);
+            } });
+    }
+    async capture(targetElement) {
+        try {
+            const element = targetElement || this.options.targetElement || document.body;
+            const options = this.buildCaptureOptions();
+            const dataUrl = await (0, html_to_image_1.toPng)(element, options);
+            // Compress the screenshot to reduce payload size
+            // Converts to WebP if supported, resizes if too large
+            const compressed = await (0, compress_1.compressImage)(dataUrl);
+            return compressed;
+        }
+        catch (error) {
+            this.handleError('capturing screenshot', error);
+            return this.getErrorPlaceholder();
+        }
+    }
+}
+exports.ScreenshotCapture = ScreenshotCapture;

package/dist/collectors/dom.d.ts

@@ -0,0 +1,67 @@
+import type { eventWithTime } from '@rrweb/types';
+import type { Sanitizer } from '../utils/sanitize';
+export interface DOMCollectorConfig {
+    /** Duration in seconds to keep replay events (default: 15) */
+    duration?: number;
+    /** Sampling configuration for performance optimization */
+    sampling?: {
+        /** Throttle mousemove events (ms, default: 50) */
+        mousemove?: number;
+        /** Throttle scroll events (ms, default: 100) */
+        scroll?: number;
+    };
+    /** Whether to record canvas elements (default: false) */
+    recordCanvas?: boolean;
+    /** Whether to record cross-origin iframes (default: false) */
+    recordCrossOriginIframes?: boolean;
+    /** Sanitizer for PII protection */
+    sanitizer?: Sanitizer;
+}
+export declare class DOMCollector {
+    private buffer;
+    private stopRecordingFn?;
+    private isRecording;
+    private config;
+    private sanitizer?;
+    constructor(config?: DOMCollectorConfig);
+    /**
+     * Start recording DOM events
+     */
+    startRecording(): void;
+    /**
+     * Stop recording DOM events
+     */
+    stopRecording(): void;
+    /**
+     * Get all events from the buffer
+     */
+    getEvents(): eventWithTime[];
+    /**
+     * Get compressed events from the buffer
+     */
+    getCompressedEvents(): eventWithTime[];
+    /**
+     * Clear all events from the buffer
+     */
+    clearBuffer(): void;
+    /**
+     * Check if currently recording
+     */
+    isCurrentlyRecording(): boolean;
+    /**
+     * Get the current buffer size
+     */
+    getBufferSize(): number;
+    /**
+     * Update the buffer duration
+     */
+    setDuration(seconds: number): void;
+    /**
+     * Get the buffer duration
+     */
+    getDuration(): number;
+    /**
+     * Destroy the collector and clean up resources
+     */
+    destroy(): void;
+}