@bugspotter/sdk 0.1.0-alpha.1

package/dist/collectors/dom.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMCollector = void 0;
+const rrweb_1 = require("rrweb");
+const buffer_1 = require("../core/buffer");
+/**
+ * DOM Collector - Records user interactions and DOM mutations
+ * @packageDocumentation
+ */
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.getLogger)();
+class DOMCollector {
+    constructor(config = {}) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        this.isRecording = false;
+        this.sanitizer = config.sanitizer;
+        this.config = {
+            duration: (_a = config.duration) !== null && _a !== void 0 ? _a : 15,
+            sampling: {
+                mousemove: (_c = (_b = config.sampling) === null || _b === void 0 ? void 0 : _b.mousemove) !== null && _c !== void 0 ? _c : 50,
+                scroll: (_e = (_d = config.sampling) === null || _d === void 0 ? void 0 : _d.scroll) !== null && _e !== void 0 ? _e : 100,
+            },
+            recordCanvas: (_f = config.recordCanvas) !== null && _f !== void 0 ? _f : false,
+            recordCrossOriginIframes: (_g = config.recordCrossOriginIframes) !== null && _g !== void 0 ? _g : false,
+            sanitizer: config.sanitizer,
+        };
+        this.buffer = new buffer_1.CircularBuffer({
+            duration: this.config.duration,
+        });
+    }
+    /**
+     * Start recording DOM events
+     */
+    startRecording() {
+        var _a, _b, _c, _d;
+        if (this.isRecording) {
+            (0, logger_1.getLogger)().warn('DOMCollector: Recording already in progress');
+            return;
+        }
+        try {
+            const recordConfig = {
+                emit: (event) => {
+                    this.buffer.add(event);
+                },
+                sampling: {
+                    mousemove: (_b = (_a = this.config.sampling) === null || _a === void 0 ? void 0 : _a.mousemove) !== null && _b !== void 0 ? _b : 50,
+                    scroll: (_d = (_c = this.config.sampling) === null || _c === void 0 ? void 0 : _c.scroll) !== null && _d !== void 0 ? _d : 100,
+                    // Also throttle mouse interactions slightly for better performance
+                    mouseInteraction: {
+                        MouseUp: false,
+                        MouseDown: false,
+                        Click: false,
+                        ContextMenu: false,
+                        DblClick: false,
+                        Focus: false,
+                        Blur: false,
+                        TouchStart: false,
+                        TouchEnd: false,
+                    },
+                },
+                recordCanvas: this.config.recordCanvas,
+                recordCrossOriginIframes: this.config.recordCrossOriginIframes,
+                // PII sanitization for text content
+                maskTextFn: this.sanitizer
+                    ? (text, element) => {
+                        return this.sanitizer.sanitizeTextNode(text, element);
+                    }
+                    : undefined,
+                // Performance optimizations
+                slimDOMOptions: {
+                    script: true, // Don't record script tags
+                    comment: true, // Don't record comments
+                    headFavicon: true, // Don't record favicon
+                    headWhitespace: true, // Don't record whitespace in head
+                    headMetaSocial: true, // Don't record social media meta tags
+                    headMetaRobots: true, // Don't record robots meta tags
+                    headMetaHttpEquiv: true, // Don't record http-equiv meta tags
+                    headMetaAuthorship: true, // Don't record authorship meta tags
+                    headMetaVerification: true, // Don't record verification meta tags
+                },
+                // Don't inline images to keep payload size down
+                inlineImages: false,
+                // Collect fonts for proper replay
+                collectFonts: false,
+            };
+            this.stopRecordingFn = (0, rrweb_1.record)(recordConfig);
+            this.isRecording = true;
+            (0, logger_1.getLogger)().debug('DOMCollector: Started recording');
+        }
+        catch (error) {
+            (0, logger_1.getLogger)().error('DOMCollector: Failed to start recording', error);
+            this.isRecording = false;
+        }
+    }
+    /**
+     * Stop recording DOM events
+     */
+    stopRecording() {
+        if (!this.isRecording || !this.stopRecordingFn) {
+            logger.warn('DOMCollector: No recording in progress');
+            return;
+        }
+        try {
+            this.stopRecordingFn();
+            this.isRecording = false;
+            this.stopRecordingFn = undefined;
+            logger.debug('DOMCollector: Stopped recording');
+        }
+        catch (error) {
+            logger.error('DOMCollector: Failed to stop recording', error);
+        }
+    }
+    /**
+     * Get all events from the buffer
+     */
+    getEvents() {
+        return this.buffer.getEvents();
+    }
+    /**
+     * Get compressed events from the buffer
+     */
+    getCompressedEvents() {
+        return this.buffer.getCompressedEvents();
+    }
+    /**
+     * Clear all events from the buffer
+     */
+    clearBuffer() {
+        this.buffer.clear();
+    }
+    /**
+     * Check if currently recording
+     */
+    isCurrentlyRecording() {
+        return this.isRecording;
+    }
+    /**
+     * Get the current buffer size
+     */
+    getBufferSize() {
+        return this.buffer.size();
+    }
+    /**
+     * Update the buffer duration
+     */
+    setDuration(seconds) {
+        this.config.duration = seconds;
+        this.buffer.setDuration(seconds);
+    }
+    /**
+     * Get the buffer duration
+     */
+    getDuration() {
+        return this.config.duration;
+    }
+    /**
+     * Destroy the collector and clean up resources
+     */
+    destroy() {
+        this.stopRecording();
+        this.clearBuffer();
+    }
+}
+exports.DOMCollector = DOMCollector;

package/dist/collectors/index.d.ts

@@ -0,0 +1,2 @@
+export { DOMCollector } from './dom';
+export type { DOMCollectorConfig } from './dom';

package/dist/collectors/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMCollector = void 0;
+var dom_1 = require("./dom");
+Object.defineProperty(exports, "DOMCollector", { enumerable: true, get: function () { return dom_1.DOMCollector; } });

package/dist/core/buffer.d.ts

@@ -0,0 +1,50 @@
+import type { eventWithTime } from '@rrweb/types';
+export interface CircularBufferConfig {
+    /** Duration in seconds to keep events */
+    duration: number;
+}
+/**
+ * Time-based circular buffer for storing replay events.
+ * Automatically prunes events older than the configured duration.
+ */
+export declare class CircularBuffer<T extends eventWithTime = eventWithTime> {
+    private events;
+    private duration;
+    constructor(config: CircularBufferConfig);
+    /**
+     * Add an event to the buffer
+     */
+    add(event: T): void;
+    /**
+     * Add multiple events to the buffer
+     */
+    addBatch(events: T[]): void;
+    /**
+     * Remove events older than the configured duration
+     */
+    private prune;
+    /**
+     * Get all events in the buffer
+     */
+    getEvents(): T[];
+    /**
+     * Get compressed event data
+     */
+    getCompressedEvents(): T[];
+    /**
+     * Clear all events from the buffer
+     */
+    clear(): void;
+    /**
+     * Get the current size of the buffer
+     */
+    size(): number;
+    /**
+     * Update the buffer duration
+     */
+    setDuration(seconds: number): void;
+    /**
+     * Get the buffer duration in seconds
+     */
+    getDuration(): number;
+}

package/dist/core/buffer.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircularBuffer = void 0;
+/**
+ * Time-based circular buffer for storing replay events.
+ * Automatically prunes events older than the configured duration.
+ */
+class CircularBuffer {
+    constructor(config) {
+        this.events = [];
+        this.duration = config.duration * 1000; // convert to milliseconds
+    }
+    /**
+     * Add an event to the buffer
+     */
+    add(event) {
+        this.events.push(event);
+        this.prune();
+    }
+    /**
+     * Add multiple events to the buffer
+     */
+    addBatch(events) {
+        this.events.push(...events);
+        this.prune();
+    }
+    /**
+     * Remove events older than the configured duration
+     */
+    prune() {
+        if (this.events.length === 0) {
+            return;
+        }
+        const now = Date.now();
+        const cutoffTime = now - this.duration;
+        // Find the first event that should be kept
+        let firstValidIndex = 0;
+        for (let i = 0; i < this.events.length; i++) {
+            if (this.events[i].timestamp >= cutoffTime) {
+                firstValidIndex = i;
+                break;
+            }
+        }
+        // Remove old events
+        if (firstValidIndex > 0) {
+            this.events = this.events.slice(firstValidIndex);
+        }
+    }
+    /**
+     * Get all events in the buffer
+     */
+    getEvents() {
+        this.prune(); // Ensure we don't return stale events
+        return [...this.events]; // Return a copy
+    }
+    /**
+     * Get compressed event data
+     */
+    getCompressedEvents() {
+        return this.getEvents();
+    }
+    /**
+     * Clear all events from the buffer
+     */
+    clear() {
+        this.events = [];
+    }
+    /**
+     * Get the current size of the buffer
+     */
+    size() {
+        return this.events.length;
+    }
+    /**
+     * Update the buffer duration
+     */
+    setDuration(seconds) {
+        this.duration = seconds * 1000;
+        this.prune();
+    }
+    /**
+     * Get the buffer duration in seconds
+     */
+    getDuration() {
+        return this.duration / 1000;
+    }
+}
+exports.CircularBuffer = CircularBuffer;

package/dist/core/circular-buffer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A generic circular buffer implementation for storing a fixed number of items.
+ * When the buffer is full, new items overwrite the oldest items.
+ *
+ * @template T The type of items stored in the buffer
+ */
+export declare class CircularBuffer<T> {
+    private maxSize;
+    private items;
+    private index;
+    private count;
+    constructor(maxSize: number);
+    /**
+     * Add an item to the buffer. If the buffer is full, the oldest item is overwritten.
+     */
+    add(item: T): void;
+    /**
+     * Get all items in chronological order (oldest to newest).
+     * Returns a copy of the internal array.
+     */
+    getAll(): T[];
+    /**
+     * Clear all items from the buffer.
+     */
+    clear(): void;
+    /**
+     * Get the current number of items in the buffer.
+     */
+    get size(): number;
+    /**
+     * Get the maximum capacity of the buffer.
+     */
+    get capacity(): number;
+    /**
+     * Check if the buffer is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Check if the buffer is full.
+     */
+    get isFull(): boolean;
+}

package/dist/core/circular-buffer.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircularBuffer = void 0;
+/**
+ * A generic circular buffer implementation for storing a fixed number of items.
+ * When the buffer is full, new items overwrite the oldest items.
+ *
+ * @template T The type of items stored in the buffer
+ */
+class CircularBuffer {
+    constructor(maxSize) {
+        this.maxSize = maxSize;
+        this.items = [];
+        this.index = 0;
+        this.count = 0;
+        if (maxSize <= 0) {
+            throw new Error('CircularBuffer maxSize must be greater than 0');
+        }
+    }
+    /**
+     * Add an item to the buffer. If the buffer is full, the oldest item is overwritten.
+     */
+    add(item) {
+        if (this.count < this.maxSize) {
+            this.items.push(item);
+            this.count++;
+        }
+        else {
+            this.items[this.index] = item;
+        }
+        this.index = (this.index + 1) % this.maxSize;
+    }
+    /**
+     * Get all items in chronological order (oldest to newest).
+     * Returns a copy of the internal array.
+     */
+    getAll() {
+        if (this.count < this.maxSize) {
+            return [...this.items];
+        }
+        // Return items in chronological order when buffer is full
+        return [...this.items.slice(this.index), ...this.items.slice(0, this.index)];
+    }
+    /**
+     * Clear all items from the buffer.
+     */
+    clear() {
+        this.items = [];
+        this.index = 0;
+        this.count = 0;
+    }
+    /**
+     * Get the current number of items in the buffer.
+     */
+    get size() {
+        return this.count;
+    }
+    /**
+     * Get the maximum capacity of the buffer.
+     */
+    get capacity() {
+        return this.maxSize;
+    }
+    /**
+     * Check if the buffer is empty.
+     */
+    get isEmpty() {
+        return this.count === 0;
+    }
+    /**
+     * Check if the buffer is full.
+     */
+    get isFull() {
+        return this.count >= this.maxSize;
+    }
+}
+exports.CircularBuffer = CircularBuffer;

package/dist/core/compress.d.ts

@@ -0,0 +1,49 @@
+export interface CompressionConfig {
+    gzipLevel?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -1;
+    imageMaxWidth?: number;
+    imageMaxHeight?: number;
+    webpQuality?: number;
+    jpegQuality?: number;
+    verbose?: boolean;
+}
+/**
+ * Compress JSON or string data using gzip
+ * @param data - Data to compress (will be JSON stringified if object)
+ * @param config - Optional compression configuration
+ * @returns Compressed data as Uint8Array
+ */
+export declare function compressData(data: unknown, config?: CompressionConfig): Promise<Uint8Array>;
+/**
+ * Decompress gzipped data back to original format
+ * Useful for testing and verification
+ * @param compressed - Compressed Uint8Array data
+ * @param config - Optional configuration
+ * @returns Decompressed and parsed data (or string if input was string)
+ */
+export declare function decompressData(compressed: Uint8Array, config?: Pick<CompressionConfig, 'verbose'>): unknown;
+/**
+ * Optimize and compress screenshot image
+ * Converts to WebP if supported, resizes if too large, then compresses
+ * @param base64 - Base64 encoded image (PNG or other format)
+ * @param config - Optional compression configuration
+ * @returns Optimized base64 image string
+ */
+export declare function compressImage(base64: string, config?: CompressionConfig): Promise<string>;
+/**
+ * Calculate compression ratio for analytics
+ * @param originalSize - Original data size in bytes
+ * @param compressedSize - Compressed data size in bytes
+ * @returns Compression ratio as percentage (0-100)
+ */
+export declare function getCompressionRatio(originalSize: number, compressedSize: number): number;
+/**
+ * Estimate payload size before compression
+ * @param data - Data to estimate
+ * @returns Estimated size in bytes
+ */
+export declare function estimateSize(data: unknown): number;
+/**
+ * Reset cached instances (useful for testing)
+ * @internal
+ */
+export declare function resetCompressionCache(): void;