@tracelog/lib 0.0.1

package/dist/cjs/types/event.types.d.ts

@@ -0,0 +1,104 @@
+import { MetadataType } from './common.types';
+import { SessionEndReason } from './session.types';
+export type WebVitalType = 'LCP' | 'CLS' | 'INP' | 'FCP' | 'TTFB' | 'LONG_TASK';
+export declare enum EventType {
+    PAGE_VIEW = "page_view",
+    CLICK = "click",
+    SCROLL = "scroll",
+    SESSION_START = "session_start",
+    SESSION_END = "session_end",
+    CUSTOM = "custom",
+    WEB_VITALS = "web_vitals",
+    ERROR = "error"
+}
+export declare enum ScrollDirection {
+    UP = "up",
+    DOWN = "down"
+}
+export declare enum ErrorType {
+    JS_ERROR = "js_error",
+    PROMISE_REJECTION = "promise_rejection",
+    NETWORK_ERROR = "network_error"
+}
+export interface ScrollData {
+    depth: number;
+    direction: ScrollDirection;
+}
+export interface ClickData {
+    x: number;
+    y: number;
+    relativeX: number;
+    relativeY: number;
+    id?: string;
+    class?: string;
+    tag?: string;
+    text?: string;
+    href?: string;
+    title?: string;
+    alt?: string;
+    role?: string;
+    ariaLabel?: string;
+    dataAttributes?: Record<string, string>;
+}
+export interface ClickCoordinates {
+    x: number;
+    y: number;
+    relativeX: number;
+    relativeY: number;
+}
+export interface ClickTrackingElementData {
+    element: HTMLElement;
+    name: string;
+    value?: string;
+}
+export interface CustomEventData {
+    name: string;
+    metadata?: Record<string, MetadataType>;
+}
+export interface WebVitalsData {
+    type: WebVitalType;
+    value: number;
+}
+export interface ErrorData {
+    type: ErrorType;
+    message: string;
+    method?: string;
+    url?: string;
+    status?: number;
+    statusText?: string;
+    duration?: number;
+}
+export interface UTM {
+    source?: string;
+    medium?: string;
+    campaign?: string;
+    term?: string;
+    content?: string;
+}
+export interface PageViewData {
+    referrer?: string;
+    title?: string;
+    pathname?: string;
+    search?: string;
+    hash?: string;
+}
+export interface EventData {
+    type: EventType;
+    page_url: string;
+    timestamp: number;
+    referrer?: string;
+    from_page_url?: string;
+    scroll_data?: ScrollData;
+    click_data?: ClickData;
+    custom_event?: CustomEventData;
+    web_vitals?: WebVitalsData;
+    page_view?: PageViewData;
+    session_start_recovered?: boolean;
+    session_end_reason?: SessionEndReason;
+    error_data?: ErrorData;
+    utm?: UTM;
+    tags?: string[] | {
+        id: string;
+        key: string;
+    }[];
+}

package/dist/cjs/types/event.types.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorType = exports.ScrollDirection = exports.EventType = void 0;
+var EventType;
+(function (EventType) {
+    EventType["PAGE_VIEW"] = "page_view";
+    EventType["CLICK"] = "click";
+    EventType["SCROLL"] = "scroll";
+    EventType["SESSION_START"] = "session_start";
+    EventType["SESSION_END"] = "session_end";
+    EventType["CUSTOM"] = "custom";
+    EventType["WEB_VITALS"] = "web_vitals";
+    EventType["ERROR"] = "error";
+})(EventType || (exports.EventType = EventType = {}));
+var ScrollDirection;
+(function (ScrollDirection) {
+    ScrollDirection["UP"] = "up";
+    ScrollDirection["DOWN"] = "down";
+})(ScrollDirection || (exports.ScrollDirection = ScrollDirection = {}));
+var ErrorType;
+(function (ErrorType) {
+    ErrorType["JS_ERROR"] = "js_error";
+    ErrorType["PROMISE_REJECTION"] = "promise_rejection";
+    ErrorType["NETWORK_ERROR"] = "network_error";
+})(ErrorType || (exports.ErrorType = ErrorType = {}));

package/dist/cjs/types/index.d.ts

@@ -0,0 +1,13 @@
+export * from './api.types';
+export * from './common.types';
+export * from './config.types';
+export * from './device.types';
+export * from './event.types';
+export * from './log.types';
+export * from './mode.types';
+export * from './queue.types';
+export * from './state.types';
+export * from './tag.types';
+export * from './validation-error.types';
+export * from './web-vitals.types';
+export * from './window.types';

package/dist/cjs/types/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api.types"), exports);
+__exportStar(require("./common.types"), exports);
+__exportStar(require("./config.types"), exports);
+__exportStar(require("./device.types"), exports);
+__exportStar(require("./event.types"), exports);
+__exportStar(require("./log.types"), exports);
+__exportStar(require("./mode.types"), exports);
+__exportStar(require("./queue.types"), exports);
+__exportStar(require("./state.types"), exports);
+__exportStar(require("./tag.types"), exports);
+__exportStar(require("./validation-error.types"), exports);
+__exportStar(require("./web-vitals.types"), exports);
+__exportStar(require("./window.types"), exports);

package/dist/cjs/types/log.types.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Log levels for the dual logging system
+ */
+export type LogLevel = 'CLIENT_ERROR' | 'CLIENT_WARN' | 'INFO' | 'ERROR' | 'WARN' | 'DEBUG' | 'VERBOSE';

package/dist/cjs/types/log.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/mode.types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * App modes for the TraceLog Library
+ */
+export declare enum Mode {
+    QA = "qa",
+    DEBUG = "debug"
+}

package/dist/cjs/types/mode.types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mode = void 0;
+/**
+ * App modes for the TraceLog Library
+ */
+var Mode;
+(function (Mode) {
+    Mode["QA"] = "qa";
+    Mode["DEBUG"] = "debug";
+})(Mode || (exports.Mode = Mode = {}));

package/dist/cjs/types/queue.types.d.ts

@@ -0,0 +1,23 @@
+import { MetadataType } from './common.types';
+import { DeviceType } from './device.types';
+import { EventData } from './event.types';
+export interface BaseEventsQueueDto {
+    user_id: string;
+    session_id: string;
+    device: DeviceType;
+    events: EventData[];
+    global_metadata?: Record<string, MetadataType>;
+}
+export interface ExtendedEventsQueueDto extends BaseEventsQueueDto {
+    project: string;
+    source: string;
+    ip: string;
+}
+export interface PersistedQueueData {
+    userId: string;
+    sessionId: string;
+    device: BaseEventsQueueDto['device'];
+    events: BaseEventsQueueDto['events'];
+    timestamp: number;
+    global_metadata?: BaseEventsQueueDto['global_metadata'];
+}

package/dist/cjs/types/queue.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/session.types.d.ts

@@ -0,0 +1,65 @@
+export type SessionEndReason = 'inactivity' | 'page_unload' | 'manual_stop' | 'orphaned_cleanup' | 'tab_closed';
+export interface SessionEndConfig {
+    enablePageUnloadHandlers: boolean;
+    syncTimeoutMs: number;
+    maxRetries: number;
+    debugMode: boolean;
+}
+export interface SessionEndResult {
+    success: boolean;
+    reason: SessionEndReason;
+    timestamp: number;
+    eventsFlushed: number;
+    method: 'async' | 'sync';
+}
+export interface SessionEndStats {
+    totalSessionEnds: number;
+    successfulEnds: number;
+    failedEnds: number;
+    duplicatePrevented: number;
+    reasonCounts: Record<SessionEndReason, number>;
+}
+export interface CrossTabSessionConfig {
+    tabHeartbeatIntervalMs: number;
+    tabElectionTimeoutMs: number;
+    debugMode: boolean;
+}
+export interface TabInfo {
+    id: string;
+    lastHeartbeat: number;
+    isLeader: boolean;
+    sessionId: string;
+    startTime: number;
+}
+export interface CrossTabMessage {
+    type: 'heartbeat' | 'session_start' | 'session_end' | 'tab_closing' | 'election_request' | 'election_response';
+    tabId: string;
+    sessionId?: string;
+    timestamp: number;
+    data?: Record<string, unknown>;
+}
+export interface SessionRecoveryConfig {
+    recoveryWindowMs: number;
+    maxRecoveryAttempts: number;
+    contextPreservation: boolean;
+}
+export interface SessionContext {
+    sessionId: string;
+    startTime: number;
+    lastActivity: number;
+    tabCount: number;
+    recoveryAttempts: number;
+    metadata?: Record<string, unknown>;
+}
+export interface RecoveryAttempt {
+    sessionId: string;
+    timestamp: number;
+    attempt: number;
+    context: SessionContext;
+}
+export interface SessionHealth {
+    recoveryAttempts: number;
+    sessionTimeouts: number;
+    crossTabConflicts: number;
+    lastHealthCheck: number;
+}

package/dist/cjs/types/session.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/state.types.d.ts

@@ -0,0 +1,12 @@
+import { Config } from './config.types';
+import { DeviceType } from './device.types';
+export interface State {
+    apiUrl: string;
+    config: Config;
+    sessionId: string | null;
+    userId: string;
+    device: DeviceType;
+    pageUrl: string;
+    hasStartSession: boolean;
+    suppressNextScroll: boolean;
+}

package/dist/cjs/types/state.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/tag.types.d.ts

@@ -0,0 +1,43 @@
+import { EventType } from './event.types';
+export declare enum TagLogicalOperator {
+    AND = "AND",
+    OR = "OR"
+}
+export declare enum TagConditionType {
+    URL_MATCHES = "url_matches",
+    ELEMENT_MATCHES = "element_matches",
+    DEVICE_TYPE = "device_type",
+    ELEMENT_TEXT = "element_text",
+    ELEMENT_ATTRIBUTE = "element_attribute",
+    UTM_SOURCE = "utm_source",
+    UTM_MEDIUM = "utm_medium",
+    UTM_CAMPAIGN = "utm_campaign"
+}
+export declare enum TagConditionOperator {
+    EQUALS = "equals",
+    CONTAINS = "contains",
+    STARTS_WITH = "starts_with",
+    ENDS_WITH = "ends_with",
+    REGEX = "regex",
+    GREATER_THAN = "greater_than",
+    LESS_THAN = "less_than",
+    EXISTS = "exists",
+    NOT_EXISTS = "not_exists"
+}
+export type TagConfig = Pick<Tag, 'key' | 'triggerType' | 'logicalOperator' | 'conditions'> & {
+    id: string;
+};
+export interface Tag {
+    key: string;
+    name: string;
+    description?: string;
+    active: boolean;
+    triggerType: EventType;
+    logicalOperator?: TagLogicalOperator;
+    conditions: TagCondition[];
+}
+export interface TagCondition {
+    type: TagConditionType;
+    operator: TagConditionOperator;
+    value: string;
+}

package/dist/cjs/types/tag.types.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagConditionOperator = exports.TagConditionType = exports.TagLogicalOperator = void 0;
+var TagLogicalOperator;
+(function (TagLogicalOperator) {
+    TagLogicalOperator["AND"] = "AND";
+    TagLogicalOperator["OR"] = "OR";
+})(TagLogicalOperator || (exports.TagLogicalOperator = TagLogicalOperator = {}));
+var TagConditionType;
+(function (TagConditionType) {
+    TagConditionType["URL_MATCHES"] = "url_matches";
+    TagConditionType["ELEMENT_MATCHES"] = "element_matches";
+    TagConditionType["DEVICE_TYPE"] = "device_type";
+    TagConditionType["ELEMENT_TEXT"] = "element_text";
+    TagConditionType["ELEMENT_ATTRIBUTE"] = "element_attribute";
+    TagConditionType["UTM_SOURCE"] = "utm_source";
+    TagConditionType["UTM_MEDIUM"] = "utm_medium";
+    TagConditionType["UTM_CAMPAIGN"] = "utm_campaign";
+})(TagConditionType || (exports.TagConditionType = TagConditionType = {}));
+var TagConditionOperator;
+(function (TagConditionOperator) {
+    TagConditionOperator["EQUALS"] = "equals";
+    TagConditionOperator["CONTAINS"] = "contains";
+    TagConditionOperator["STARTS_WITH"] = "starts_with";
+    TagConditionOperator["ENDS_WITH"] = "ends_with";
+    TagConditionOperator["REGEX"] = "regex";
+    TagConditionOperator["GREATER_THAN"] = "greater_than";
+    TagConditionOperator["LESS_THAN"] = "less_than";
+    TagConditionOperator["EXISTS"] = "exists";
+    TagConditionOperator["NOT_EXISTS"] = "not_exists";
+})(TagConditionOperator || (exports.TagConditionOperator = TagConditionOperator = {}));

package/dist/cjs/types/validation-error.types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Custom error classes for TraceLog validation errors
+ * Provides better error handling and consistency across validation layers
+ */
+/**
+ * Base class for all TraceLog validation errors
+ */
+export declare abstract class TraceLogValidationError extends Error {
+    readonly errorCode: string;
+    readonly layer: 'config' | 'app' | 'runtime';
+    constructor(message: string, errorCode: string, layer: 'config' | 'app' | 'runtime');
+}
+/**
+ * Thrown when project ID validation fails
+ */
+export declare class ProjectIdValidationError extends TraceLogValidationError {
+    constructor(message?: string, layer?: 'config' | 'app' | 'runtime');
+}
+/**
+ * Thrown when app configuration validation fails
+ */
+export declare class AppConfigValidationError extends TraceLogValidationError {
+    constructor(message: string, layer?: 'config' | 'app' | 'runtime');
+}
+/**
+ * Thrown when session timeout validation fails
+ */
+export declare class SessionTimeoutValidationError extends TraceLogValidationError {
+    constructor(message: string, layer?: 'config' | 'app' | 'runtime');
+}
+/**
+ * Thrown when sampling rate validation fails
+ */
+export declare class SamplingRateValidationError extends TraceLogValidationError {
+    constructor(message: string, layer?: 'config' | 'app' | 'runtime');
+}
+/**
+ * Thrown when integrations validation fails
+ */
+export declare class IntegrationValidationError extends TraceLogValidationError {
+    constructor(message: string, layer?: 'config' | 'app' | 'runtime');
+}

package/dist/cjs/types/validation-error.types.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Custom error classes for TraceLog validation errors
+ * Provides better error handling and consistency across validation layers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationValidationError = exports.SamplingRateValidationError = exports.SessionTimeoutValidationError = exports.AppConfigValidationError = exports.ProjectIdValidationError = exports.TraceLogValidationError = void 0;
+/**
+ * Base class for all TraceLog validation errors
+ */
+class TraceLogValidationError extends Error {
+    constructor(message, errorCode, layer) {
+        super(message);
+        this.errorCode = errorCode;
+        this.layer = layer;
+        this.name = this.constructor.name;
+        // Maintains proper stack trace for where error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+exports.TraceLogValidationError = TraceLogValidationError;
+/**
+ * Thrown when project ID validation fails
+ */
+class ProjectIdValidationError extends TraceLogValidationError {
+    constructor(message = 'Project ID is required', layer = 'config') {
+        super(message, 'PROJECT_ID_INVALID', layer);
+    }
+}
+exports.ProjectIdValidationError = ProjectIdValidationError;
+/**
+ * Thrown when app configuration validation fails
+ */
+class AppConfigValidationError extends TraceLogValidationError {
+    constructor(message, layer = 'config') {
+        super(message, 'APP_CONFIG_INVALID', layer);
+    }
+}
+exports.AppConfigValidationError = AppConfigValidationError;
+/**
+ * Thrown when session timeout validation fails
+ */
+class SessionTimeoutValidationError extends TraceLogValidationError {
+    constructor(message, layer = 'config') {
+        super(message, 'SESSION_TIMEOUT_INVALID', layer);
+    }
+}
+exports.SessionTimeoutValidationError = SessionTimeoutValidationError;
+/**
+ * Thrown when sampling rate validation fails
+ */
+class SamplingRateValidationError extends TraceLogValidationError {
+    constructor(message, layer = 'config') {
+        super(message, 'SAMPLING_RATE_INVALID', layer);
+    }
+}
+exports.SamplingRateValidationError = SamplingRateValidationError;
+/**
+ * Thrown when integrations validation fails
+ */
+class IntegrationValidationError extends TraceLogValidationError {
+    constructor(message, layer = 'config') {
+        super(message, 'INTEGRATION_INVALID', layer);
+    }
+}
+exports.IntegrationValidationError = IntegrationValidationError;

package/dist/cjs/types/web-vitals.types.d.ts

@@ -0,0 +1,6 @@
+import { WebVitalType } from './event.types';
+export type NavigationId = string;
+export interface VitalSample {
+    type: WebVitalType;
+    value: number;
+}

package/dist/cjs/types/web-vitals.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/window.types.d.ts

@@ -0,0 +1,17 @@
+import type { App } from '../app';
+/**
+ * Testing bridge interface for E2E tests
+ * Only available when NODE_ENV=dev
+ */
+export interface TraceLogTestBridge extends App {
+    isInitializing(): boolean;
+}
+declare global {
+    interface Window {
+        /**
+         * Testing bridge for E2E tests
+         * Only available when NODE_ENV=dev
+         */
+        __traceLogBridge?: TraceLogTestBridge;
+    }
+}

package/dist/cjs/types/window.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils/browser/device-detector.utils.d.ts

@@ -0,0 +1,6 @@
+import { DeviceType } from '../../types/device.types';
+/**
+ * Detects the device type based on screen size, user agent, and browser capabilities
+ * @returns The detected device type
+ */
+export declare const getDeviceType: () => DeviceType;

package/dist/cjs/utils/browser/device-detector.utils.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeviceType = void 0;
+const device_types_1 = require("../../types/device.types");
+const logging_1 = require("../logging");
+let coarsePointerQuery;
+let noHoverQuery;
+const initMediaQueries = () => {
+    if (typeof window !== 'undefined' && !coarsePointerQuery) {
+        coarsePointerQuery = window.matchMedia('(pointer: coarse)');
+        noHoverQuery = window.matchMedia('(hover: none)');
+    }
+};
+/**
+ * Detects the device type based on screen size, user agent, and browser capabilities
+ * @returns The detected device type
+ */
+const getDeviceType = () => {
+    try {
+        logging_1.debugLog.debug('DeviceDetector', 'Starting device detection');
+        const nav = navigator;
+        if (nav.userAgentData && typeof nav.userAgentData.mobile === 'boolean') {
+            logging_1.debugLog.debug('DeviceDetector', 'Using modern User-Agent Client Hints API', {
+                mobile: nav.userAgentData.mobile,
+                platform: nav.userAgentData.platform,
+            });
+            if (nav.userAgentData.platform && /ipad|tablet/i.test(nav.userAgentData.platform)) {
+                logging_1.debugLog.debug('DeviceDetector', 'Device detected as tablet via platform hint');
+                return device_types_1.DeviceType.Tablet;
+            }
+            const result = nav.userAgentData.mobile ? device_types_1.DeviceType.Mobile : device_types_1.DeviceType.Desktop;
+            logging_1.debugLog.debug('DeviceDetector', 'Device detected via User-Agent hints', { result });
+            return result;
+        }
+        logging_1.debugLog.debug('DeviceDetector', 'Using fallback detection methods');
+        initMediaQueries();
+        const width = window.innerWidth;
+        const hasCoarsePointer = coarsePointerQuery?.matches ?? false;
+        const hasNoHover = noHoverQuery?.matches ?? false;
+        const hasTouchSupport = 'ontouchstart' in window || navigator.maxTouchPoints > 0;
+        const ua = navigator.userAgent.toLowerCase();
+        const isMobileUA = /mobile|android|iphone|ipod|blackberry|iemobile|opera mini/.test(ua);
+        const isTabletUA = /tablet|ipad|android(?!.*mobile)/.test(ua);
+        const detectionData = {
+            width,
+            hasCoarsePointer,
+            hasNoHover,
+            hasTouchSupport,
+            isMobileUA,
+            isTabletUA,
+            maxTouchPoints: navigator.maxTouchPoints,
+        };
+        if (width <= 767 || (isMobileUA && hasTouchSupport)) {
+            logging_1.debugLog.debug('DeviceDetector', 'Device detected as mobile', detectionData);
+            return device_types_1.DeviceType.Mobile;
+        }
+        if ((width >= 768 && width <= 1024) || isTabletUA || (hasCoarsePointer && hasNoHover && hasTouchSupport)) {
+            logging_1.debugLog.debug('DeviceDetector', 'Device detected as tablet', detectionData);
+            return device_types_1.DeviceType.Tablet;
+        }
+        logging_1.debugLog.debug('DeviceDetector', 'Device detected as desktop', detectionData);
+        return device_types_1.DeviceType.Desktop;
+    }
+    catch (error) {
+        logging_1.debugLog.warn('DeviceDetector', 'Device detection failed, defaulting to desktop', {
+            error: error instanceof Error ? error.message : error,
+        });
+        return device_types_1.DeviceType.Desktop;
+    }
+};
+exports.getDeviceType = getDeviceType;

package/dist/cjs/utils/browser/index.d.ts

@@ -0,0 +1,2 @@
+export * from './device-detector.utils';
+export * from './utm-params.utils';

package/dist/cjs/utils/browser/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./device-detector.utils"), exports);
+__exportStar(require("./utm-params.utils"), exports);

package/dist/cjs/utils/browser/utm-params.utils.d.ts

@@ -0,0 +1,6 @@
+import { UTM } from '../../types/event.types';
+/**
+ * Extracts UTM parameters from the current URL
+ * @returns UTM parameters object or undefined if none found
+ */
+export declare const getUTMParameters: () => UTM | undefined;