@tracelog/lib 0.5.4 → 0.6.0

package/dist/cjs/utils/browser/qa-mode.utils.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectQaMode = void 0;
+const constants_1 = require("@/constants");
+const logging_utils_1 = require("../logging.utils");
+const QA_MODE_PARAM = 'tlog_mode';
+const QA_MODE_VALUE = 'qa';
+/**
+ * Detects if QA mode should be active based on URL query parameter or sessionStorage
+ *
+ * Detection flow:
+ * 1. Check if already active in sessionStorage
+ * 2. Check for ?tlog_mode=qa query parameter
+ * 3. If found in URL:
+ *    - Persist to sessionStorage
+ *    - Clean param from URL
+ *
+ * @returns True if QA mode is active, false otherwise
+ */
+const detectQaMode = () => {
+    const stored = sessionStorage.getItem(constants_1.QA_MODE_KEY);
+    if (stored === 'true') {
+        return true;
+    }
+    const params = new URLSearchParams(window.location.search);
+    const modeParam = params.get(QA_MODE_PARAM);
+    const isQaMode = modeParam === QA_MODE_VALUE;
+    if (isQaMode) {
+        sessionStorage.setItem(constants_1.QA_MODE_KEY, 'true');
+        params.delete(QA_MODE_PARAM);
+        const newSearch = params.toString();
+        const newUrl = `${window.location.pathname}${newSearch ? '?' + newSearch : ''}${window.location.hash}`;
+        try {
+            window.history.replaceState({}, '', newUrl);
+        }
+        catch (error) {
+            (0, logging_utils_1.log)('warn', 'History API not available, cannot replace URL', { error });
+        }
+        console.log('%c[TraceLog] QA Mode ACTIVE', 'background: #ff9800; color: white; font-weight: bold; padding: 2px 8px; border-radius: 3px;');
+    }
+    return isQaMode;
+};
+exports.detectQaMode = detectQaMode;

package/dist/cjs/utils/browser/utm-params.utils.js

@@ -2,16 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUTMParameters = void 0;
 const constants_1 = require("../../constants");
-const logging_1 = require("../logging");
 /**
  * Extracts UTM parameters from the current URL
  * @returns UTM parameters object or undefined if none found
  */
 const getUTMParameters = () => {
-    logging_1.debugLog.debug('UTMParams', 'Extracting UTM parameters from URL', {
-        url: window.location.href,
-        search: window.location.search,
-    });
     const urlParams = new URLSearchParams(window.location.search);
     const utmParams = {};
     constants_1.UTM_PARAMS.forEach((param) => {
@@ -19,19 +14,9 @@ const getUTMParameters = () => {
         if (value) {
             const key = param.split('utm_')[1];
             utmParams[key] = value;
-            logging_1.debugLog.debug('UTMParams', 'Found UTM parameter', { param, key, value });
         }
     });
     const result = Object.keys(utmParams).length ? utmParams : undefined;
-    if (result) {
-        logging_1.debugLog.debug('UTMParams', 'UTM parameters extracted successfully', {
-            parameterCount: Object.keys(result).length,
-            parameters: Object.keys(result),
-        });
-    }
-    else {
-        logging_1.debugLog.debug('UTMParams', 'No UTM parameters found in URL');
-    }
     return result;
 };
 exports.getUTMParameters = getUTMParameters;

package/dist/cjs/utils/data/uuid.utils.d.ts

@@ -3,3 +3,16 @@
  * @returns A UUID string
  */
 export declare const generateUUID: () => string;
+/**
+ * Generates a unique event ID optimized for high-frequency event tracking
+ *
+ * Uses a simple hybrid approach:
+ * - Timestamp for temporal ordering
+ * - Random component for uniqueness across tabs/processes
+ *
+ * Format: {timestamp}-{random}
+ * Example: "1704067200000-a3f9c2b1"
+ *
+ * @returns Unique event ID string
+ */
+export declare const generateEventId: () => string;

package/dist/cjs/utils/data/uuid.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateUUID = void 0;
+exports.generateEventId = exports.generateUUID = void 0;
 /**
  * Generates a RFC4122 compliant UUID v4 using native crypto API with fallback
  * @returns A UUID string
@@ -18,3 +18,39 @@ const generateUUID = () => {
     });
 };
 exports.generateUUID = generateUUID;
+/**
+ * Generates a unique event ID optimized for high-frequency event tracking
+ *
+ * Uses a simple hybrid approach:
+ * - Timestamp for temporal ordering
+ * - Random component for uniqueness across tabs/processes
+ *
+ * Format: {timestamp}-{random}
+ * Example: "1704067200000-a3f9c2b1"
+ *
+ * @returns Unique event ID string
+ */
+const generateEventId = () => {
+    const timestamp = Date.now();
+    // Generate 8 random hex chars (32 bits entropy)
+    let random = '';
+    try {
+        if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+            const bytes = crypto.getRandomValues(new Uint8Array(4));
+            if (bytes) {
+                random = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+            }
+        }
+    }
+    catch {
+        // crypto failed, use fallback
+    }
+    // Fallback to Math.random if crypto unavailable
+    if (!random) {
+        random = Math.floor(Math.random() * 0xffffffff)
+            .toString(16)
+            .padStart(8, '0');
+    }
+    return `${timestamp}-${random}`;
+};
+exports.generateEventId = generateEventId;

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

@@ -1,7 +1,7 @@
 export * from './browser';
 export * from './data';
-export * from './logging';
 export * from './network';
 export * from './security';
 export * from './validations';
 export * from './emitter.utils';
+export * from './logging.utils';

package/dist/cjs/utils/index.js

@@ -16,8 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./browser"), exports);
 __exportStar(require("./data"), exports);
-__exportStar(require("./logging"), exports);
 __exportStar(require("./network"), exports);
 __exportStar(require("./security"), exports);
 __exportStar(require("./validations"), exports);
 __exportStar(require("./emitter.utils"), exports);
+__exportStar(require("./logging.utils"), exports);

package/dist/cjs/utils/logging.utils.d.ts

@@ -0,0 +1,6 @@
+export declare const formatLogMsg: (msg: string, error?: unknown) => string;
+export declare const log: (type: "info" | "warn" | "error", msg: string, extra?: {
+    error?: unknown;
+    data?: Record<string, unknown>;
+    showToClient?: boolean;
+}) => void;

package/dist/cjs/utils/logging.utils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = exports.formatLogMsg = void 0;
+const formatLogMsg = (msg, error) => {
+    if (error) {
+        return `[TraceLog] ${msg}: ${error instanceof Error ? error.message : 'Unknown error'}`;
+    }
+    return `[TraceLog] ${msg}`;
+};
+exports.formatLogMsg = formatLogMsg;
+const log = (type, msg, extra) => {
+    const { error, data, showToClient } = extra ?? {};
+    const formattedMsg = error ? (0, exports.formatLogMsg)(msg, error) : `[TraceLog] ${msg}`;
+    const method = type === 'error' ? 'error' : type === 'warn' ? 'warn' : 'log';
+    if (process.env.NODE_ENV !== 'dev' && !showToClient) {
+        return;
+    }
+    if (data !== undefined) {
+        console[method](formattedMsg, data);
+    }
+    else {
+        console[method](formattedMsg);
+    }
+};
+exports.log = log;

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

@@ -1,2 +1 @@
 export * from './url.utils';
-export * from './fetch-with-timeout.utils';

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

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./url.utils"), exports);
-__exportStar(require("./fetch-with-timeout.utils"), exports);

package/dist/cjs/utils/network/url.utils.d.ts

@@ -1,9 +1,10 @@
+import { Config } from '@/types';
 /**
  * Generates an API URL based on project ID and current domain
  * @param id - The project ID
  * @returns The generated API URL
  */
-export declare const getApiUrl: (id: string, allowHttp?: boolean) => string;
+export declare const getApiUrl: (config: Config) => string;
 /**
  * Normalizes a URL by removing sensitive query parameters
  * @param url - The URL to normalize
@@ -11,10 +12,3 @@ export declare const getApiUrl: (id: string, allowHttp?: boolean) => string;
  * @returns The normalized URL
  */
 export declare const normalizeUrl: (url: string, sensitiveQueryParams?: string[]) => string;
-/**
- * Checks if a URL path should be excluded from tracking
- * @param url - The URL to check
- * @param excludedPaths - Array of patterns to match against
- * @returns True if the URL should be excluded
- */
-export declare const isUrlPathExcluded: (url: string, excludedPaths?: string[]) => boolean;

package/dist/cjs/utils/network/url.utils.js

@@ -1,33 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUrlPathExcluded = exports.normalizeUrl = exports.getApiUrl = void 0;
-const validations_1 = require("../validations");
-const logging_1 = require("../logging");
+exports.normalizeUrl = exports.getApiUrl = void 0;
+const logging_utils_1 = require("../logging.utils");
+/**
+ * Validates if a URL is valid and optionally allows HTTP URLs
+ * @param url - The URL to validate
+ * @param allowHttp - Whether to allow HTTP URLs (default: false)
+ * @returns True if the URL is valid, false otherwise
+ */
+const isValidUrl = (url, allowHttp = false) => {
+    try {
+        const parsed = new URL(url);
+        const isHttps = parsed.protocol === 'https:';
+        const isHttp = parsed.protocol === 'http:';
+        return isHttps || (allowHttp && isHttp);
+    }
+    catch {
+        return false;
+    }
+};
 /**
  * Generates an API URL based on project ID and current domain
  * @param id - The project ID
  * @returns The generated API URL
  */
-const getApiUrl = (id, allowHttp = false) => {
-    const url = new URL(window.location.href);
-    const host = url.hostname;
-    const parts = host.split('.');
-    if (parts.length === 0) {
-        logging_1.debugLog.clientError('URLUtils', 'Invalid hostname - no domain parts found', { hostname: host });
-        throw new Error('Invalid URL');
+const getApiUrl = (config) => {
+    const allowHttp = config.allowHttp ?? false;
+    if (config.integrations?.tracelog?.projectId) {
+        const url = new URL(window.location.href);
+        const host = url.hostname;
+        const parts = host.split('.');
+        if (parts.length === 0) {
+            throw new Error('Invalid URL');
+        }
+        const projectId = config.integrations.tracelog.projectId;
+        const cleanDomain = parts.slice(-2).join('.');
+        const protocol = allowHttp && url.protocol === 'http:' ? 'http' : 'https';
+        const apiUrl = `${protocol}://${projectId}.${cleanDomain}`;
+        const isValid = isValidUrl(apiUrl, allowHttp);
+        if (!isValid) {
+            throw new Error('Invalid URL');
+        }
+        return apiUrl;
     }
-    const cleanDomain = parts.slice(-2).join('.');
-    const protocol = allowHttp && url.protocol === 'http:' ? 'http' : 'https';
-    const apiUrl = `${protocol}://${id}.${cleanDomain}`;
-    const isValid = (0, validations_1.isValidUrl)(apiUrl, allowHttp);
-    if (!isValid) {
-        logging_1.debugLog.clientError('URLUtils', 'Generated API URL failed validation', {
-            apiUrl,
-            allowHttp,
-        });
-        throw new Error('Invalid URL');
+    if (config.integrations?.custom?.apiUrl) {
+        const apiUrl = config.integrations.custom.apiUrl;
+        const isValid = isValidUrl(apiUrl, allowHttp);
+        if (!isValid) {
+            throw new Error('Invalid URL');
+        }
+        return apiUrl;
     }
-    return apiUrl;
+    return '';
 };
 exports.getApiUrl = getApiUrl;
 /**
@@ -40,7 +64,6 @@ const normalizeUrl = (url, sensitiveQueryParams = []) => {
     try {
         const urlObject = new URL(url);
         const searchParams = urlObject.searchParams;
-        const originalParamCount = Array.from(searchParams.keys()).length;
         let hasChanged = false;
         const removedParams = [];
         sensitiveQueryParams.forEach((param) => {
@@ -50,13 +73,6 @@ const normalizeUrl = (url, sensitiveQueryParams = []) => {
                 removedParams.push(param);
             }
         });
-        if (hasChanged) {
-            logging_1.debugLog.debug('URLUtils', 'Sensitive parameters removed from URL', {
-                removedParams,
-                originalParamCount,
-                finalParamCount: Array.from(searchParams.keys()).length,
-            });
-        }
         if (!hasChanged && url.includes('?')) {
             return url;
         }
@@ -65,68 +81,8 @@ const normalizeUrl = (url, sensitiveQueryParams = []) => {
         return result;
     }
     catch (error) {
-        logging_1.debugLog.warn('URLUtils', 'URL normalization failed, returning original', {
-            url: url.slice(0, 100),
-            error: error instanceof Error ? error.message : error,
-        });
+        (0, logging_utils_1.log)('warn', 'URL normalization failed, returning original', { error, data: { url: url.slice(0, 100) } });
         return url;
     }
 };
 exports.normalizeUrl = normalizeUrl;
-/**
- * Checks if a URL path should be excluded from tracking
- * @param url - The URL to check
- * @param excludedPaths - Array of patterns to match against
- * @returns True if the URL should be excluded
- */
-const isUrlPathExcluded = (url, excludedPaths = []) => {
-    if (excludedPaths.length === 0) {
-        return false;
-    }
-    let path;
-    try {
-        const parsedUrl = new URL(url, window.location.origin);
-        path = parsedUrl.pathname + (parsedUrl.hash ?? '');
-    }
-    catch (error) {
-        logging_1.debugLog.warn('URLUtils', 'Failed to parse URL for path exclusion check', {
-            url: url.slice(0, 100),
-            error: error instanceof Error ? error.message : error,
-        });
-        return false;
-    }
-    const isRegularExpression = (value) => typeof value === 'object' && value !== undefined && typeof value.test === 'function';
-    const escapeRegexString = (string_) => string_.replaceAll(/[$()*+.?[\\\]^{|}]/g, '\\$&');
-    const wildcardToRegex = (string_) => new RegExp('^' +
-        string_
-            .split('*')
-            .map((element) => escapeRegexString(element))
-            .join('.+') +
-        '$');
-    const matchedPattern = excludedPaths.find((pattern) => {
-        try {
-            if (isRegularExpression(pattern)) {
-                const matches = pattern.test(path);
-                return matches;
-            }
-            if (pattern.includes('*')) {
-                const regex = wildcardToRegex(pattern);
-                const matches = regex.test(path);
-                return matches;
-            }
-            const matches = pattern === path;
-            return matches;
-        }
-        catch (error) {
-            logging_1.debugLog.warn('URLUtils', 'Error testing exclusion pattern', {
-                pattern,
-                path,
-                error: error instanceof Error ? error.message : error,
-            });
-            return false;
-        }
-    });
-    const isExcluded = !!matchedPattern;
-    return isExcluded;
-};
-exports.isUrlPathExcluded = isUrlPathExcluded;

package/dist/cjs/utils/security/sanitize.utils.d.ts

@@ -1,22 +1,10 @@
-import { MetadataType, ApiConfig } from '../../types';
+import { MetadataType } from '../../types';
 /**
  * Sanitizes a string value to prevent XSS attacks
  * @param value - The string to sanitize
  * @returns The sanitized string
  */
 export declare const sanitizeString: (value: string) => string;
-/**
- * Sanitizes a path string for route exclusion checks
- * @param value - The path string to sanitize
- * @returns The sanitized path string
- */
-export declare const sanitizePathString: (value: string) => string;
-/**
- * Sanitizes API configuration data with strict validation
- * @param data - The API config data to sanitize
- * @returns The sanitized API config
- */
-export declare const sanitizeApiConfig: (data: unknown) => ApiConfig;
 /**
  * Sanitizes user metadata for custom events
  * @param metadata - The metadata to sanitize