@v-tilt/browser 1.6.0 → 1.7.0

package/lib/extensions/replay/types.d.ts

@@ -1,211 +0,0 @@
-/**
- * Session Recording Types
- *
- * Type definitions for rrweb session recording.
- * Based on PostHog's implementation.
- */
-import type { blockClass, eventWithTime, hooksParam, KeepIframeSrcFn, maskTextClass, PackFn, RecordPlugin, SamplingStrategy } from "@rrweb/types";
-/** Mask options for input elements */
-export type MaskInputOptions = Partial<{
-    color: boolean;
-    date: boolean;
-    "datetime-local": boolean;
-    email: boolean;
-    month: boolean;
-    number: boolean;
-    range: boolean;
-    search: boolean;
-    tel: boolean;
-    text: boolean;
-    time: boolean;
-    url: boolean;
-    week: boolean;
-    textarea: boolean;
-    select: boolean;
-    password: boolean;
-}>;
-/** Function to mask input values */
-export type MaskInputFn = (text: string, element: HTMLElement) => string;
-/** Function to mask text content */
-export type MaskTextFn = (text: string, element: HTMLElement | null) => string;
-/** Options for slim DOM mode */
-export type SlimDOMOptions = Partial<{
-    script: boolean;
-    comment: boolean;
-    headFavicon: boolean;
-    headWhitespace: boolean;
-    headMetaDescKeywords: boolean;
-    headMetaSocial: boolean;
-    headMetaRobots: boolean;
-    headMetaHttpEquiv: boolean;
-    headMetaAuthorship: boolean;
-    headMetaVerification: boolean;
-    headTitleMutations: boolean;
-}>;
-/** Options for data URL generation */
-export type DataURLOptions = Partial<{
-    type: string;
-    quality: number;
-}>;
-/** Error handler type */
-export type ErrorHandler = (error: unknown) => void | boolean;
-/** rrweb record options */
-export interface RecordOptions {
-    emit?: (e: eventWithTime, isCheckout?: boolean) => void;
-    checkoutEveryNth?: number;
-    checkoutEveryNms?: number;
-    blockClass?: blockClass;
-    blockSelector?: string;
-    ignoreClass?: string;
-    ignoreSelector?: string;
-    maskTextClass?: maskTextClass;
-    maskTextSelector?: string;
-    maskAllInputs?: boolean;
-    maskInputOptions?: MaskInputOptions;
-    maskInputFn?: MaskInputFn;
-    maskTextFn?: MaskTextFn;
-    slimDOMOptions?: SlimDOMOptions | "all" | true;
-    ignoreCSSAttributes?: Set<string>;
-    inlineStylesheet?: boolean;
-    hooks?: hooksParam;
-    packFn?: PackFn;
-    sampling?: SamplingStrategy;
-    dataURLOptions?: DataURLOptions;
-    recordDOM?: boolean;
-    recordCanvas?: boolean;
-    recordCrossOriginIframes?: boolean;
-    recordAfter?: "DOMContentLoaded" | "load";
-    userTriggeredOnInput?: boolean;
-    collectFonts?: boolean;
-    inlineImages?: boolean;
-    plugins?: RecordPlugin[];
-    mousemoveWait?: number;
-    keepIframeSrcFn?: KeepIframeSrcFn;
-    errorHandler?: ErrorHandler;
-}
-/** rrweb record function type */
-export interface RRWebRecord {
-    (options: RecordOptions): () => void;
-    addCustomEvent: (tag: string, payload: unknown) => void;
-    takeFullSnapshot: () => void;
-    mirror: {
-        getId(n: Node | undefined | null): number;
-        getNode(id: number): Node | null;
-    };
-}
-/** Canvas recording configuration */
-export interface CanvasRecordingConfig {
-    enabled: boolean;
-    fps: number;
-    quality: number;
-}
-/** Network payload capture configuration */
-export interface NetworkPayloadCaptureConfig {
-    recordHeaders?: boolean;
-    recordBody?: boolean;
-    recordPerformance?: boolean;
-}
-/** Masking configuration */
-export interface MaskingConfig {
-    maskAllInputs?: boolean;
-    maskTextSelector?: string;
-    blockSelector?: string;
-}
-/** Session recording configuration */
-export interface SessionRecordingConfig {
-    /** Enable session recording */
-    enabled?: boolean;
-    /** Sample rate (0-1, where 1 = 100%) */
-    sampleRate?: number;
-    /** Minimum session duration in ms before sending */
-    minimumDurationMs?: number;
-    /** Session idle threshold in ms */
-    sessionIdleThresholdMs?: number;
-    /** Full snapshot interval in ms */
-    fullSnapshotIntervalMs?: number;
-    /** Enable console log capture */
-    captureConsole?: boolean;
-    /** Enable network request capture */
-    captureNetwork?: boolean;
-    /** Canvas recording settings */
-    captureCanvas?: {
-        recordCanvas?: boolean;
-        canvasFps?: number;
-        canvasQuality?: number;
-    };
-    /** Masking settings */
-    masking?: MaskingConfig;
-    /** Block class for elements to hide */
-    blockClass?: string;
-    /** Block selector for elements to hide */
-    blockSelector?: string;
-    /** Ignore class for input masking */
-    ignoreClass?: string;
-    /** Mask text class */
-    maskTextClass?: string;
-    /** Mask text selector */
-    maskTextSelector?: string;
-    /** Mask all inputs */
-    maskAllInputs?: boolean;
-    /** Mask input options */
-    maskInputOptions?: MaskInputOptions;
-    /** Record headers in network requests */
-    recordHeaders?: boolean;
-    /** Record body in network requests */
-    recordBody?: boolean;
-    /** Compress events before sending */
-    compressEvents?: boolean;
-    /** Internal: Mutation throttler refill rate */
-    __mutationThrottlerRefillRate?: number;
-    /** Internal: Mutation throttler bucket size */
-    __mutationThrottlerBucketSize?: number;
-}
-/** Recording status values */
-export type SessionRecordingStatus = "disabled" | "buffering" | "active" | "paused" | "sampled" | "trigger_pending";
-/** Recording start reason */
-export type SessionStartReason = "recording_initialized" | "session_id_changed" | "linked_flag_matched" | "linked_flag_overridden" | "sampling_overridden" | "url_trigger_matched" | "event_trigger_matched" | "sampled";
-/** Trigger type for starting recording */
-export type TriggerType = "url" | "event";
-/** Buffer for snapshot events */
-export interface SnapshotBuffer {
-    size: number;
-    data: eventWithTime[];
-    sessionId: string;
-    windowId: string;
-}
-/** Remote configuration for session recording */
-export interface SessionRecordingRemoteConfig {
-    enabled?: boolean;
-    endpoint?: string;
-    sampleRate?: string;
-    minimumDurationMilliseconds?: number;
-    consoleLogRecordingEnabled?: boolean;
-    networkPayloadCapture?: {
-        recordHeaders?: boolean;
-        recordBody?: boolean;
-        capturePerformance?: boolean;
-    };
-    masking?: MaskingConfig;
-    recordCanvas?: boolean;
-    canvasFps?: number;
-    canvasQuality?: number;
-    scriptConfig?: {
-        script?: string;
-    };
-    triggerMatchType?: "any" | "all";
-    urlTriggers?: Array<{
-        url: string;
-        matching: "regex" | "exact" | "contains";
-    }>;
-    urlBlocklist?: Array<{
-        url: string;
-        matching: "regex" | "exact" | "contains";
-    }>;
-    eventTriggers?: string[];
-}
-/** Queued rrweb method call */
-export interface QueuedRRWebEvent {
-    rrwebMethod: () => void;
-    attempt: number;
-    enqueuedAt: number;
-}

package/lib/extensions/replay/types.js

@@ -1,8 +0,0 @@
-"use strict";
-/**
- * Session Recording Types
- *
- * Type definitions for rrweb session recording.
- * Based on PostHog's implementation.
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/geolocation.d.ts

@@ -1,5 +0,0 @@
-import { GeolocationData } from "./types";
-/**
- * Get country and locale from timezone and navigator
- */
-export declare function getCountryAndLocale(): GeolocationData;

package/lib/geolocation.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCountryAndLocale = getCountryAndLocale;
-const constants_1 = require("./constants");
-const globals_1 = require("./utils/globals");
-/**
- * Get country and locale from timezone and navigator
- */
-function getCountryAndLocale() {
-    let country;
-    let locale;
-    // Only get geolocation data in browser environment (not SSR)
-    if (!globals_1.navigator) {
-        return { country, locale };
-    }
-    try {
-        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-        country = constants_1.TIMEZONES[timezone];
-        locale =
-            globals_1.navigator.languages && globals_1.navigator.languages.length
-                ? globals_1.navigator.languages[0]
-                : globals_1.navigator.userLanguage ||
-                    globals_1.navigator.language ||
-                    globals_1.navigator.browserLanguage ||
-                    "en";
-    }
-    catch (_error) {
-        // ignore error
-    }
-    return { country, locale };
-}

package/lib/rate-limiter.d.ts

@@ -1,52 +0,0 @@
-/**
- * Rate Limiter - Token Bucket Algorithm (PostHog-style)
- *
- * Prevents runaway loops from flooding the server with events.
- * Uses a token bucket algorithm with configurable rate and burst limits.
- *
- * Features:
- * - Configurable events per second (default: 10)
- * - Configurable burst limit (default: 100)
- * - Token replenishment over time
- * - Warning event when rate limited
- */
-export declare const RATE_LIMIT_WARNING_EVENT = "$$client_ingestion_warning";
-export interface RateLimitBucket {
-    tokens: number;
-    last: number;
-}
-export interface RateLimiterConfig {
-    eventsPerSecond?: number;
-    eventsBurstLimit?: number;
-    persistence?: {
-        get: (key: string) => RateLimitBucket | null;
-        set: (key: string, value: RateLimitBucket) => void;
-    };
-    captureWarning?: (message: string) => void;
-}
-export declare class RateLimiter {
-    private eventsPerSecond;
-    private eventsBurstLimit;
-    private lastEventRateLimited;
-    private persistence?;
-    private captureWarning?;
-    constructor(config?: RateLimiterConfig);
-    /**
-     * Check if the client should be rate limited
-     *
-     * @param checkOnly - If true, don't consume a token (just check)
-     * @returns Object with isRateLimited flag and remaining tokens
-     */
-    checkRateLimit(checkOnly?: boolean): {
-        isRateLimited: boolean;
-        remainingTokens: number;
-    };
-    /**
-     * Check if an event should be allowed (consumes a token if allowed)
-     */
-    shouldAllowEvent(): boolean;
-    /**
-     * Get remaining tokens without consuming
-     */
-    getRemainingTokens(): number;
-}

package/lib/rate-limiter.js

@@ -1,80 +0,0 @@
-"use strict";
-/**
- * Rate Limiter - Token Bucket Algorithm (PostHog-style)
- *
- * Prevents runaway loops from flooding the server with events.
- * Uses a token bucket algorithm with configurable rate and burst limits.
- *
- * Features:
- * - Configurable events per second (default: 10)
- * - Configurable burst limit (default: 100)
- * - Token replenishment over time
- * - Warning event when rate limited
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RateLimiter = exports.RATE_LIMIT_WARNING_EVENT = void 0;
-const RATE_LIMIT_STORAGE_KEY = "vt_rate_limit";
-exports.RATE_LIMIT_WARNING_EVENT = "$$client_ingestion_warning";
-class RateLimiter {
-    constructor(config = {}) {
-        var _a, _b;
-        this.lastEventRateLimited = false;
-        this.eventsPerSecond = (_a = config.eventsPerSecond) !== null && _a !== void 0 ? _a : 10;
-        this.eventsBurstLimit = Math.max((_b = config.eventsBurstLimit) !== null && _b !== void 0 ? _b : this.eventsPerSecond * 10, this.eventsPerSecond);
-        this.persistence = config.persistence;
-        this.captureWarning = config.captureWarning;
-        // Initialize lastEventRateLimited from current state
-        this.lastEventRateLimited = this.checkRateLimit(true).isRateLimited;
-    }
-    /**
-     * Check if the client should be rate limited
-     *
-     * @param checkOnly - If true, don't consume a token (just check)
-     * @returns Object with isRateLimited flag and remaining tokens
-     */
-    checkRateLimit(checkOnly = false) {
-        var _a, _b, _c, _d;
-        const now = Date.now();
-        // Get current bucket state from persistence or create new
-        const bucket = (_b = (_a = this.persistence) === null || _a === void 0 ? void 0 : _a.get(RATE_LIMIT_STORAGE_KEY)) !== null && _b !== void 0 ? _b : {
-            tokens: this.eventsBurstLimit,
-            last: now,
-        };
-        // Replenish tokens based on time elapsed
-        const secondsElapsed = (now - bucket.last) / 1000;
-        bucket.tokens += secondsElapsed * this.eventsPerSecond;
-        bucket.last = now;
-        // Cap tokens at burst limit
-        if (bucket.tokens > this.eventsBurstLimit) {
-            bucket.tokens = this.eventsBurstLimit;
-        }
-        const isRateLimited = bucket.tokens < 1;
-        // Consume a token if not just checking
-        if (!isRateLimited && !checkOnly) {
-            bucket.tokens = Math.max(0, bucket.tokens - 1);
-        }
-        // Capture warning event when first rate limited
-        if (isRateLimited && !this.lastEventRateLimited && !checkOnly) {
-            (_c = this.captureWarning) === null || _c === void 0 ? void 0 : _c.call(this, `vTilt client rate limited. Config: ${this.eventsPerSecond} events/second, ${this.eventsBurstLimit} burst limit.`);
-        }
-        this.lastEventRateLimited = isRateLimited;
-        (_d = this.persistence) === null || _d === void 0 ? void 0 : _d.set(RATE_LIMIT_STORAGE_KEY, bucket);
-        return {
-            isRateLimited,
-            remainingTokens: bucket.tokens,
-        };
-    }
-    /**
-     * Check if an event should be allowed (consumes a token if allowed)
-     */
-    shouldAllowEvent() {
-        return !this.checkRateLimit(false).isRateLimited;
-    }
-    /**
-     * Get remaining tokens without consuming
-     */
-    getRemainingTokens() {
-        return this.checkRateLimit(true).remainingTokens;
-    }
-}
-exports.RateLimiter = RateLimiter;

package/lib/request-queue.d.ts

@@ -1,78 +0,0 @@
-/**
- * Request Queue - Event Batching (PostHog-style)
- *
- * Batches multiple events together and sends them at configurable intervals.
- * This reduces the number of HTTP requests significantly for active users.
- *
- * Features:
- * - Configurable flush interval (default 3 seconds)
- * - Batches events by URL/batchKey
- * - Uses sendBeacon on page unload for reliable delivery
- * - Converts absolute timestamps to relative offsets before sending
- */
-import type { TrackingEvent } from "./types";
-export declare const DEFAULT_FLUSH_INTERVAL_MS = 3000;
-export interface QueuedRequest {
-    url: string;
-    event: TrackingEvent;
-    batchKey?: string;
-    transport?: "xhr" | "sendBeacon";
-}
-export interface BatchedRequest {
-    url: string;
-    events: TrackingEvent[];
-    batchKey?: string;
-    transport?: "xhr" | "sendBeacon";
-}
-export interface RequestQueueConfig {
-    flush_interval_ms?: number;
-}
-export declare class RequestQueue {
-    private _isPaused;
-    private _queue;
-    private _flushTimeout?;
-    private _flushTimeoutMs;
-    private _sendRequest;
-    constructor(sendRequest: (req: BatchedRequest) => void, config?: RequestQueueConfig);
-    /**
-     * Get the current queue length
-     */
-    get length(): number;
-    /**
-     * Enqueue an event for batched sending
-     */
-    enqueue(req: QueuedRequest): void;
-    /**
-     * Flush all queued events immediately using sendBeacon
-     * Called on page unload to ensure events are delivered
-     */
-    unload(): void;
-    /**
-     * Enable the queue and start flushing
-     */
-    enable(): void;
-    /**
-     * Pause the queue (stops flushing but keeps events)
-     */
-    pause(): void;
-    /**
-     * Force an immediate flush
-     */
-    flush(): void;
-    /**
-     * Set up the flush timeout
-     */
-    private _setFlushTimeout;
-    /**
-     * Clear the flush timeout
-     */
-    private _clearFlushTimeout;
-    /**
-     * Flush all queued events now
-     */
-    private _flushNow;
-    /**
-     * Format the queue into batched requests by URL/batchKey
-     */
-    private _formatQueue;
-}

package/lib/request-queue.js

@@ -1,156 +0,0 @@
-"use strict";
-/**
- * Request Queue - Event Batching (PostHog-style)
- *
- * Batches multiple events together and sends them at configurable intervals.
- * This reduces the number of HTTP requests significantly for active users.
- *
- * Features:
- * - Configurable flush interval (default 3 seconds)
- * - Batches events by URL/batchKey
- * - Uses sendBeacon on page unload for reliable delivery
- * - Converts absolute timestamps to relative offsets before sending
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequestQueue = exports.DEFAULT_FLUSH_INTERVAL_MS = void 0;
-exports.DEFAULT_FLUSH_INTERVAL_MS = 3000;
-/**
- * Clamp a value to a range
- */
-function clampToRange(value, min, max, defaultValue) {
-    if (typeof value !== "number" || isNaN(value)) {
-        return defaultValue;
-    }
-    return Math.min(Math.max(value, min), max);
-}
-class RequestQueue {
-    constructor(sendRequest, config) {
-        // We start in a paused state and only start flushing when enabled
-        this._isPaused = true;
-        this._queue = [];
-        this._flushTimeoutMs = clampToRange((config === null || config === void 0 ? void 0 : config.flush_interval_ms) || exports.DEFAULT_FLUSH_INTERVAL_MS, 250, // Min 250ms
-        5000, // Max 5 seconds
-        exports.DEFAULT_FLUSH_INTERVAL_MS);
-        this._sendRequest = sendRequest;
-    }
-    /**
-     * Get the current queue length
-     */
-    get length() {
-        return this._queue.length;
-    }
-    /**
-     * Enqueue an event for batched sending
-     */
-    enqueue(req) {
-        this._queue.push(req);
-        // Start flush timer if not already running
-        if (!this._flushTimeout) {
-            this._setFlushTimeout();
-        }
-    }
-    /**
-     * Flush all queued events immediately using sendBeacon
-     * Called on page unload to ensure events are delivered
-     */
-    unload() {
-        this._clearFlushTimeout();
-        if (this._queue.length === 0) {
-            return;
-        }
-        const requests = this._formatQueue();
-        // Send each batched request using sendBeacon for reliable delivery
-        for (const key in requests) {
-            const req = requests[key];
-            this._sendRequest({ ...req, transport: "sendBeacon" });
-        }
-    }
-    /**
-     * Enable the queue and start flushing
-     */
-    enable() {
-        this._isPaused = false;
-        this._setFlushTimeout();
-    }
-    /**
-     * Pause the queue (stops flushing but keeps events)
-     */
-    pause() {
-        this._isPaused = true;
-        this._clearFlushTimeout();
-    }
-    /**
-     * Force an immediate flush
-     */
-    flush() {
-        this._clearFlushTimeout();
-        this._flushNow();
-        this._setFlushTimeout();
-    }
-    /**
-     * Set up the flush timeout
-     */
-    _setFlushTimeout() {
-        if (this._isPaused) {
-            return;
-        }
-        this._flushTimeout = setTimeout(() => {
-            this._clearFlushTimeout();
-            this._flushNow();
-            // Restart the timeout for continuous flushing
-            if (this._queue.length > 0) {
-                this._setFlushTimeout();
-            }
-        }, this._flushTimeoutMs);
-    }
-    /**
-     * Clear the flush timeout
-     */
-    _clearFlushTimeout() {
-        if (this._flushTimeout) {
-            clearTimeout(this._flushTimeout);
-            this._flushTimeout = undefined;
-        }
-    }
-    /**
-     * Flush all queued events now
-     */
-    _flushNow() {
-        if (this._queue.length === 0) {
-            return;
-        }
-        const requests = this._formatQueue();
-        const now = Date.now();
-        for (const key in requests) {
-            const req = requests[key];
-            // Convert absolute timestamps to relative offsets
-            // This helps with clock skew between client and server
-            req.events.forEach((event) => {
-                const eventTime = new Date(event.timestamp).getTime();
-                event.$offset = Math.abs(eventTime - now);
-            });
-            this._sendRequest(req);
-        }
-    }
-    /**
-     * Format the queue into batched requests by URL/batchKey
-     */
-    _formatQueue() {
-        const requests = {};
-        this._queue.forEach((request) => {
-            const key = request.batchKey || request.url;
-            if (!requests[key]) {
-                requests[key] = {
-                    url: request.url,
-                    events: [],
-                    batchKey: request.batchKey,
-                };
-            }
-            requests[key].events.push(request.event);
-        });
-        // Clear the queue
-        this._queue = [];
-        return requests;
-    }
-}
-exports.RequestQueue = RequestQueue;

package/lib/request.d.ts

@@ -1,54 +0,0 @@
-/**
- * Request utilities for vTilt tracking
- *
- * Handles HTTP requests with:
- * - GZip compression (via fflate)
- * - Multiple transport methods (fetch, XHR, sendBeacon)
- * - Automatic fallback between transports
- *
- * Based on PostHog's request.ts pattern
- */
-/**
- * Compression methods supported by the SDK
- */
-export declare enum Compression {
-    GZipJS = "gzip-js",
-    None = "none"
-}
-/**
- * Response from a request
- */
-export interface RequestResponse {
-    statusCode: number;
-    text?: string;
-    json?: any;
-}
-/**
- * Options for making a request
- */
-export interface RequestOptions {
-    url: string;
-    data?: any;
-    method?: "POST" | "GET";
-    headers?: Record<string, string>;
-    transport?: "XHR" | "fetch" | "sendBeacon";
-    compression?: Compression;
-    timeout?: number;
-    callback?: (response: RequestResponse) => void;
-}
-/**
- * JSON stringify with BigInt support
- */
-export declare const jsonStringify: (data: any) => string;
-/**
- * Main request function - handles transport selection and dispatching
- */
-export declare const request: (options: RequestOptions) => void;
-/**
- * Promise-based request wrapper
- */
-export declare const requestAsync: (options: Omit<RequestOptions, "callback">) => Promise<RequestResponse>;
-/**
- * Check if compression is supported and beneficial
- */
-export declare const shouldCompress: (data: any) => boolean;