@tracelog/lib 0.5.4 → 0.6.0

package/dist/esm/utils/validations/config-validations.utils.js

@@ -1,7 +1,6 @@
-import { MAX_SESSION_TIMEOUT_MS, MIN_SESSION_TIMEOUT_MS, VALIDATION_MESSAGES } from '../../constants';
-import { Mode } from '../../types';
-import { ProjectIdValidationError, AppConfigValidationError, SessionTimeoutValidationError, SamplingRateValidationError, IntegrationValidationError, } from '../../types/validation-error.types';
-import { debugLog } from '../logging';
+import { MAX_SESSION_TIMEOUT_MS, MIN_SESSION_TIMEOUT_MS, DEFAULT_SESSION_TIMEOUT, VALIDATION_MESSAGES, } from '../../constants';
+import { AppConfigValidationError, SessionTimeoutValidationError, SamplingRateValidationError, IntegrationValidationError, } from '../../types/validation-error.types';
+import { log } from '../logging.utils';
 /**
  * Validates the app configuration object (before normalization)
  * This validates the structure and basic types but allows for normalization afterward
@@ -10,42 +9,18 @@ import { debugLog } from '../logging';
  * @throws {AppConfigValidationError} If other configuration validation fails
  */
 export const validateAppConfig = (config) => {
-    // Validate config exists and has id property
     if (!config || typeof config !== 'object') {
-        debugLog.clientError('ConfigValidation', 'Configuration must be an object', { config });
         throw new AppConfigValidationError('Configuration must be an object', 'config');
     }
-    // Check if id property exists (allow falsy values to be handled by normalization)
-    if (!('id' in config)) {
-        debugLog.clientError('ConfigValidation', 'Project ID is missing from configuration');
-        throw new ProjectIdValidationError(VALIDATION_MESSAGES.MISSING_PROJECT_ID, 'config');
-    }
-    // Check basic type - null, undefined, or non-string values should fail here
-    if (config.id === null || config.id === undefined || typeof config.id !== 'string') {
-        debugLog.clientError('ConfigValidation', 'Project ID must be a non-empty string', {
-            providedId: config.id,
-            type: typeof config.id,
-        });
-        throw new ProjectIdValidationError(VALIDATION_MESSAGES.MISSING_PROJECT_ID, 'config');
-    }
     if (config.sessionTimeout !== undefined) {
         if (typeof config.sessionTimeout !== 'number' ||
             config.sessionTimeout < MIN_SESSION_TIMEOUT_MS ||
             config.sessionTimeout > MAX_SESSION_TIMEOUT_MS) {
-            debugLog.clientError('ConfigValidation', 'Invalid session timeout', {
-                provided: config.sessionTimeout,
-                min: MIN_SESSION_TIMEOUT_MS,
-                max: MAX_SESSION_TIMEOUT_MS,
-            });
             throw new SessionTimeoutValidationError(VALIDATION_MESSAGES.INVALID_SESSION_TIMEOUT, 'config');
         }
     }
     if (config.globalMetadata !== undefined) {
         if (typeof config.globalMetadata !== 'object' || config.globalMetadata === null) {
-            debugLog.clientError('ConfigValidation', 'Global metadata must be an object', {
-                provided: config.globalMetadata,
-                type: typeof config.globalMetadata,
-            });
             throw new AppConfigValidationError(VALIDATION_MESSAGES.INVALID_GLOBAL_METADATA, 'config');
         }
     }
@@ -57,31 +32,29 @@ export const validateAppConfig = (config) => {
     }
     if (config.sensitiveQueryParams !== undefined) {
         if (!Array.isArray(config.sensitiveQueryParams)) {
-            debugLog.clientError('ConfigValidation', 'Sensitive query params must be an array', {
-                provided: config.sensitiveQueryParams,
-                type: typeof config.sensitiveQueryParams,
-            });
             throw new AppConfigValidationError(VALIDATION_MESSAGES.INVALID_SENSITIVE_QUERY_PARAMS, 'config');
         }
         for (const param of config.sensitiveQueryParams) {
             if (typeof param !== 'string') {
-                debugLog.clientError('ConfigValidation', 'All sensitive query params must be strings', {
-                    param,
-                    type: typeof param,
-                });
                 throw new AppConfigValidationError('All sensitive query params must be strings', 'config');
             }
         }
     }
     if (config.errorSampling !== undefined) {
         if (typeof config.errorSampling !== 'number' || config.errorSampling < 0 || config.errorSampling > 1) {
-            debugLog.clientError('ConfigValidation', 'Invalid error sampling rate', {
-                provided: config.errorSampling,
-                expected: '0-1',
-            });
             throw new SamplingRateValidationError(VALIDATION_MESSAGES.INVALID_ERROR_SAMPLING_RATE, 'config');
         }
     }
+    if (config.samplingRate !== undefined) {
+        if (typeof config.samplingRate !== 'number' || config.samplingRate < 0 || config.samplingRate > 1) {
+            throw new SamplingRateValidationError(VALIDATION_MESSAGES.INVALID_SAMPLING_RATE, 'config');
+        }
+    }
+    if (config.allowHttp !== undefined) {
+        if (typeof config.allowHttp !== 'boolean') {
+            throw new AppConfigValidationError('allowHttp must be a boolean', 'config');
+        }
+    }
 };
 /**
  * Validates CSS selector syntax without executing querySelector (XSS prevention)
@@ -132,19 +105,25 @@ const validateScrollContainerSelectors = (selectors) => {
     const selectorsArray = Array.isArray(selectors) ? selectors : [selectors];
     for (const selector of selectorsArray) {
         if (typeof selector !== 'string' || selector.trim() === '') {
-            debugLog.clientError('ConfigValidation', 'Invalid scroll container selector', {
-                selector,
-                type: typeof selector,
-                isEmpty: selector === '' || (typeof selector === 'string' && selector.trim() === ''),
+            log('error', 'Invalid scroll container selector', {
+                showToClient: true,
+                data: {
+                    selector,
+                    type: typeof selector,
+                    isEmpty: selector === '' || (typeof selector === 'string' && selector.trim() === ''),
+                },
             });
             throw new AppConfigValidationError(VALIDATION_MESSAGES.INVALID_SCROLL_CONTAINER_SELECTORS, 'config');
         }
         // Validate CSS selector syntax using regex-based validation (XSS prevention)
         // This validates syntax WITHOUT executing document.querySelector()
         if (!isValidCssSelectorSyntax(selector)) {
-            debugLog.clientError('ConfigValidation', 'Invalid or potentially unsafe CSS selector', {
-                selector,
-                reason: 'Failed security validation',
+            log('error', 'Invalid or potentially unsafe CSS selector', {
+                showToClient: true,
+                data: {
+                    selector,
+                    reason: 'Failed security validation',
+                },
             });
             throw new AppConfigValidationError('Invalid or potentially unsafe CSS selector', 'config');
         }
@@ -155,23 +134,34 @@ const validateScrollContainerSelectors = (selectors) => {
  * @param integrations - Integrations configuration to validate
  */
 const validateIntegrations = (integrations) => {
-    if (!integrations)
+    if (!integrations) {
         return;
+    }
+    if (integrations.tracelog) {
+        if (!integrations.tracelog.projectId ||
+            typeof integrations.tracelog.projectId !== 'string' ||
+            integrations.tracelog.projectId.trim() === '') {
+            throw new IntegrationValidationError(VALIDATION_MESSAGES.INVALID_TRACELOG_PROJECT_ID, 'config');
+        }
+    }
+    if (integrations.custom) {
+        if (!integrations.custom.apiUrl ||
+            typeof integrations.custom.apiUrl !== 'string' ||
+            integrations.custom.apiUrl.trim() === '') {
+            throw new IntegrationValidationError(VALIDATION_MESSAGES.INVALID_CUSTOM_API_URL, 'config');
+        }
+        if (!integrations.custom.apiUrl.startsWith('http')) {
+            throw new IntegrationValidationError('Custom API URL must start with "http"', 'config');
+        }
+    }
     if (integrations.googleAnalytics) {
         if (!integrations.googleAnalytics.measurementId ||
             typeof integrations.googleAnalytics.measurementId !== 'string' ||
             integrations.googleAnalytics.measurementId.trim() === '') {
-            debugLog.clientError('ConfigValidation', 'Invalid Google Analytics measurement ID', {
-                provided: integrations.googleAnalytics.measurementId,
-                type: typeof integrations.googleAnalytics.measurementId,
-            });
             throw new IntegrationValidationError(VALIDATION_MESSAGES.INVALID_GOOGLE_ANALYTICS_ID, 'config');
         }
         const measurementId = integrations.googleAnalytics.measurementId.trim();
         if (!measurementId.match(/^(G-|UA-)/)) {
-            debugLog.clientError('ConfigValidation', 'Google Analytics measurement ID must start with "G-" or "UA-"', {
-                provided: measurementId,
-            });
             throw new IntegrationValidationError('Google Analytics measurement ID must start with "G-" or "UA-"', 'config');
         }
     }
@@ -185,50 +175,15 @@ const validateIntegrations = (integrations) => {
  * @throws {AppConfigValidationError} If other configuration validation fails
  */
 export const validateAndNormalizeConfig = (config) => {
-    // First validate the structure and basic types
     validateAppConfig(config);
-    // Normalize string values
     const normalizedConfig = {
         ...config,
-        id: config.id.trim(),
+        sessionTimeout: config.sessionTimeout ?? DEFAULT_SESSION_TIMEOUT,
         globalMetadata: config.globalMetadata ?? {},
         sensitiveQueryParams: config.sensitiveQueryParams ?? [],
+        errorSampling: config.errorSampling ?? 1,
+        samplingRate: config.samplingRate ?? 1,
+        allowHttp: config.allowHttp ?? false,
     };
-    // Validate normalized values - this catches whitespace-only IDs
-    if (!normalizedConfig.id) {
-        debugLog.clientError('ConfigValidation', 'Project ID is empty after trimming whitespace', {
-            originalId: config.id,
-            normalizedId: normalizedConfig.id,
-        });
-        throw new ProjectIdValidationError(VALIDATION_MESSAGES.PROJECT_ID_EMPTY_AFTER_TRIM, 'config');
-    }
     return normalizedConfig;
 };
-/**
- * Type guard to check if a JSON response is a valid API config
- * @param json - The JSON to validate
- * @returns True if the JSON is a valid API config
- */
-export const isValidConfigApiResponse = (json) => {
-    try {
-        if (typeof json !== 'object' || !json) {
-            return false;
-        }
-        const response = json;
-        const result = {
-            mode: response['mode'] === undefined || [Mode.QA, Mode.DEBUG].includes(response['mode']),
-            // Zero is valid for samplingRate (means "sample nothing")
-            samplingRate: response['samplingRate'] === undefined ||
-                (typeof response['samplingRate'] === 'number' &&
-                    response['samplingRate'] >= 0 &&
-                    response['samplingRate'] <= 1),
-            tags: response['tags'] === undefined || Array.isArray(response['tags']),
-            excludedUrlPaths: response['excludedUrlPaths'] === undefined || Array.isArray(response['excludedUrlPaths']),
-            ipExcluded: response['ipExcluded'] === undefined || typeof response['ipExcluded'] === 'boolean',
-        };
-        return Object.values(result).every(Boolean);
-    }
-    catch {
-        return false;
-    }
-};

package/dist/esm/utils/validations/event-validations.utils.js

@@ -1,5 +1,5 @@
+import { log } from '../logging.utils';
 import { isValidEventName, isValidMetadata } from './metadata-validations.utils';
-import { debugLog } from '../logging';
 /**
  * Validates a complete event with name and optional metadata
  * @param eventName - The event name to validate
@@ -9,7 +9,10 @@ import { debugLog } from '../logging';
 export const isEventValid = (eventName, metadata) => {
     const nameValidation = isValidEventName(eventName);
     if (!nameValidation.valid) {
-        debugLog.clientError('EventValidation', 'Event name validation failed', { eventName, error: nameValidation.error });
+        log('error', 'Event name validation failed', {
+            showToClient: true,
+            data: { eventName, error: nameValidation.error },
+        });
         return nameValidation;
     }
     if (!metadata) {
@@ -17,9 +20,12 @@ export const isEventValid = (eventName, metadata) => {
     }
     const metadataValidation = isValidMetadata(eventName, metadata, 'customEvent');
     if (!metadataValidation.valid) {
-        debugLog.clientError('EventValidation', 'Event metadata validation failed', {
-            eventName,
-            error: metadataValidation.error,
+        log('error', 'Event metadata validation failed', {
+            showToClient: true,
+            data: {
+                eventName,
+                error: metadataValidation.error,
+            },
         });
     }
     return metadataValidation;

package/dist/esm/utils/validations/index.d.ts

@@ -2,4 +2,3 @@ export * from './config-validations.utils';
 export * from './event-validations.utils';
 export * from './metadata-validations.utils';
 export * from './type-guards.utils';
-export * from './url-validations.utils';

package/dist/esm/utils/validations/index.js

@@ -2,4 +2,3 @@ export * from './config-validations.utils';
 export * from './event-validations.utils';
 export * from './metadata-validations.utils';
 export * from './type-guards.utils';
-export * from './url-validations.utils';

package/dist/esm/utils/validations/metadata-validations.utils.js

@@ -138,7 +138,6 @@ export const isValidMetadata = (eventName, metadata, type) => {
                 sanitizedArray.push(itemValidation.sanitizedMetadata);
             }
         }
-        // Allow empty arrays after sanitization
         return {
             valid: true,
             sanitizedMetadata: sanitizedArray,

package/dist/esm/utils/validations/type-guards.utils.d.ts

@@ -1,6 +1,6 @@
 /**
- * Checks if an object contains only primitive fields (string, number, boolean, or string arrays)
+ * Checks if an object contains only primitive fields, string arrays, or arrays of flat objects
  * @param object - The object to check
- * @returns True if the object contains only primitive fields
+ * @returns True if the object contains only valid fields
  */
 export declare const isOnlyPrimitiveFields: (object: Record<string, unknown>) => boolean;

package/dist/esm/utils/validations/type-guards.utils.js

@@ -1,7 +1,38 @@
+import { MAX_NESTED_OBJECT_KEYS } from '../../constants';
 /**
- * Checks if an object contains only primitive fields (string, number, boolean, or string arrays)
+ * Validates if an item in an array is a valid nested object
+ * @param item - The item to validate
+ * @returns True if the item is a valid nested object
+ */
+const isValidArrayItem = (item) => {
+    if (typeof item === 'string') {
+        return true;
+    }
+    // Allow objects with primitive fields only (one level deep)
+    if (typeof item === 'object' && item !== null && !Array.isArray(item)) {
+        const entries = Object.entries(item);
+        // Check key count limit
+        if (entries.length > MAX_NESTED_OBJECT_KEYS) {
+            return false;
+        }
+        // All values must be primitives (no nested objects or arrays)
+        for (const [, value] of entries) {
+            if (value === null || value === undefined) {
+                continue;
+            }
+            const type = typeof value;
+            if (type !== 'string' && type !== 'number' && type !== 'boolean') {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+};
+/**
+ * Checks if an object contains only primitive fields, string arrays, or arrays of flat objects
  * @param object - The object to check
- * @returns True if the object contains only primitive fields
+ * @returns True if the object contains only valid fields
  */
 export const isOnlyPrimitiveFields = (object) => {
     if (typeof object !== 'object' || object === null) {
@@ -16,8 +47,23 @@ export const isOnlyPrimitiveFields = (object) => {
             continue;
         }
         if (Array.isArray(value)) {
-            if (!value.every((item) => typeof item === 'string')) {
-                return false;
+            if (value.length === 0) {
+                continue;
+            }
+            // Determine array type from first item
+            const firstItem = value[0];
+            const isStringArray = typeof firstItem === 'string';
+            // All items must be of the same type (all strings OR all objects)
+            if (isStringArray) {
+                if (!value.every((item) => typeof item === 'string')) {
+                    return false;
+                }
+            }
+            else {
+                // Must be all objects
+                if (!value.every((item) => isValidArrayItem(item))) {
+                    return false;
+                }
             }
             continue;
         }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tracelog/lib",
   "description": "JavaScript library for web analytics and real-time event tracking",
   "license": "MIT",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "main": "./dist/cjs/public-api.js",
   "module": "./dist/esm/public-api.js",
   "types": "./dist/esm/public-api.d.ts",

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

@@ -1,2 +0,0 @@
-export { Mode, EventType, DeviceType, ScrollDirection, ErrorType, TagConditionOperator, TagLogicalOperator, TagConditionType, } from './types';
-export type { ScrollData, ClickData, CustomEventData, MetadataType, WebVitalsData, ErrorData, PageViewData, UTM, EventLocation, EventData, AppConfig, ApiConfig, ExtendedEventsQueueDto, TagConfig, BaseEventsQueueDto, WebVitalType, SessionEndReason, } from './types';

package/dist/cjs/app.types.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TagConditionType = exports.TagLogicalOperator = exports.TagConditionOperator = exports.ErrorType = exports.ScrollDirection = exports.DeviceType = exports.EventType = exports.Mode = void 0;
-var types_1 = require("./types");
-Object.defineProperty(exports, "Mode", { enumerable: true, get: function () { return types_1.Mode; } });
-Object.defineProperty(exports, "EventType", { enumerable: true, get: function () { return types_1.EventType; } });
-Object.defineProperty(exports, "DeviceType", { enumerable: true, get: function () { return types_1.DeviceType; } });
-Object.defineProperty(exports, "ScrollDirection", { enumerable: true, get: function () { return types_1.ScrollDirection; } });
-Object.defineProperty(exports, "ErrorType", { enumerable: true, get: function () { return types_1.ErrorType; } });
-Object.defineProperty(exports, "TagConditionOperator", { enumerable: true, get: function () { return types_1.TagConditionOperator; } });
-Object.defineProperty(exports, "TagLogicalOperator", { enumerable: true, get: function () { return types_1.TagLogicalOperator; } });
-Object.defineProperty(exports, "TagConditionType", { enumerable: true, get: function () { return types_1.TagConditionType; } });

package/dist/cjs/constants/api.constants.d.ts

@@ -1,6 +0,0 @@
-import { ApiConfig } from '../types';
-/**
- * Default API configuration values
- * Used as fallback when API config is not available or incomplete
- */
-export declare const DEFAULT_API_CONFIG: ApiConfig;

package/dist/cjs/constants/api.constants.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_API_CONFIG = void 0;
-const config_constants_1 = require("./config.constants");
-/**
- * Default API configuration values
- * Used as fallback when API config is not available or incomplete
- */
-exports.DEFAULT_API_CONFIG = {
-    samplingRate: config_constants_1.DEFAULT_SAMPLING_RATE,
-    excludedUrlPaths: [],
-    tags: [],
-    ipExcluded: false,
-};

package/dist/cjs/managers/api.manager.d.ts

@@ -1,13 +0,0 @@
-/**
- * Generates API URL for TraceLog service based on project ID
- *
- * Handles two special cases:
- * - 'localhost:8080' or 'localhost:9999' - for local development (generates http://localhost:PORT)
- * - Regular project IDs - generates subdomain URLs via getApiUrl utility
- *
- * @param id Project ID or localhost address
- * @param allowHttp Whether to allow HTTP protocol (default: false)
- * @returns Generated API URL
- * @throws Error if URL generation or validation fails
- */
-export declare function getApiUrlForProject(id: string, allowHttp?: boolean): string;

package/dist/cjs/managers/api.manager.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getApiUrlForProject = getApiUrlForProject;
-const utils_1 = require("../utils");
-const types_1 = require("../types");
-const logging_1 = require("../utils/logging");
-/**
- * Generates API URL for TraceLog service based on project ID
- *
- * Handles two special cases:
- * - 'localhost:8080' or 'localhost:9999' - for local development (generates http://localhost:PORT)
- * - Regular project IDs - generates subdomain URLs via getApiUrl utility
- *
- * @param id Project ID or localhost address
- * @param allowHttp Whether to allow HTTP protocol (default: false)
- * @returns Generated API URL
- * @throws Error if URL generation or validation fails
- */
-function getApiUrlForProject(id, allowHttp = false) {
-    try {
-        // Handle localhost development case (localhost:8080 or localhost:9999)
-        if (id === types_1.SpecialProjectId.Localhost || id === types_1.SpecialProjectId.Fail) {
-            const url = `http://${id}`;
-            if (!(0, utils_1.isValidUrl)(url, true)) {
-                throw new Error(`Invalid localhost URL format: ${id}`);
-            }
-            return url;
-        }
-        // Handle regular project ID case
-        const url = (0, utils_1.getApiUrl)(id, allowHttp);
-        if (!(0, utils_1.isValidUrl)(url, allowHttp)) {
-            throw new Error(`Generated API URL failed validation: ${url}`);
-        }
-        return url;
-    }
-    catch (error) {
-        logging_1.debugLog.error('ApiManager', 'API URL generation failed', {
-            projectId: id,
-            allowHttp,
-            error: error instanceof Error ? error.message : error,
-        });
-        throw error;
-    }
-}

package/dist/cjs/managers/config.builder.d.ts

@@ -1,33 +0,0 @@
-import { AppConfig, ApiConfig, Config } from '../types';
-/**
- * Centralized configuration builder
- * Single source of truth for merging and building final configuration
- */
-export declare class ConfigBuilder {
-    /**
-     * Builds final configuration from app config and API config
-     * Applies clear precedence: API overrides client, with defaults as fallback
-     */
-    static build(appConfig: AppConfig, apiConfig?: ApiConfig): Config;
-    /**
-     * Resolves session timeout with validation
-     * Returns default if undefined or out of valid range
-     */
-    private static resolveSessionTimeout;
-    /**
-     * Resolves sampling rate with validation
-     * Priority: API config > app config > default
-     */
-    private static resolveSamplingRate;
-    /**
-     * Resolves error sampling rate based on mode
-     * In debug/qa modes: uses provided value or defaults to full sampling (1.0)
-     * In production: uses provided value or defaults to 10% sampling (0.1)
-     */
-    private static resolveErrorSampling;
-    /**
-     * Resolves mode with special project ID handling
-     * Priority: Special project ID > API mode > app mode
-     */
-    private static resolveMode;
-}

package/dist/cjs/managers/config.builder.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigBuilder = void 0;
-const config_constants_1 = require("../constants/config.constants");
-const types_1 = require("../types");
-const logging_1 = require("../utils/logging");
-/**
- * Centralized configuration builder
- * Single source of truth for merging and building final configuration
- */
-class ConfigBuilder {
-    /**
-     * Builds final configuration from app config and API config
-     * Applies clear precedence: API overrides client, with defaults as fallback
-     */
-    static build(appConfig, apiConfig = {}) {
-        // Resolve mode first as it affects other settings (like errorSampling)
-        const finalMode = this.resolveMode(appConfig, apiConfig.mode);
-        const config = {
-            // Core identifiers
-            id: appConfig.id,
-            // Session configuration
-            sessionTimeout: this.resolveSessionTimeout(appConfig.sessionTimeout),
-            // Mode configuration (resolved first)
-            mode: finalMode,
-            // Sampling configuration (depends on mode)
-            samplingRate: this.resolveSamplingRate(apiConfig.samplingRate, appConfig.samplingRate),
-            errorSampling: this.resolveErrorSampling(appConfig.errorSampling, finalMode),
-            // Filtering configuration
-            excludedUrlPaths: apiConfig.excludedUrlPaths ?? appConfig.excludedUrlPaths ?? [],
-            tags: apiConfig.tags ?? [],
-            ipExcluded: apiConfig.ipExcluded ?? false,
-            // Client-only configuration
-            globalMetadata: appConfig.globalMetadata ?? {},
-            scrollContainerSelectors: appConfig.scrollContainerSelectors,
-            sensitiveQueryParams: appConfig.sensitiveQueryParams ?? [],
-            integrations: appConfig.integrations,
-            // Security configuration
-            allowHttp: appConfig.allowHttp ?? false,
-        };
-        logging_1.debugLog.debug('ConfigBuilder', 'Configuration built', {
-            projectId: config.id,
-            mode: config.mode,
-            samplingRate: config.samplingRate,
-            errorSampling: config.errorSampling,
-            hasTags: !!config.tags?.length,
-            hasExclusions: !!config.excludedUrlPaths?.length,
-        });
-        return config;
-    }
-    /**
-     * Resolves session timeout with validation
-     * Returns default if undefined or out of valid range
-     */
-    static resolveSessionTimeout(timeout) {
-        if (timeout === undefined) {
-            return config_constants_1.DEFAULT_SESSION_TIMEOUT;
-        }
-        if (timeout < config_constants_1.MIN_SESSION_TIMEOUT_MS || timeout > config_constants_1.MAX_SESSION_TIMEOUT_MS) {
-            logging_1.debugLog.warn('ConfigBuilder', 'Invalid session timeout, using default', {
-                provided: timeout,
-                min: config_constants_1.MIN_SESSION_TIMEOUT_MS,
-                max: config_constants_1.MAX_SESSION_TIMEOUT_MS,
-                default: config_constants_1.DEFAULT_SESSION_TIMEOUT,
-            });
-            return config_constants_1.DEFAULT_SESSION_TIMEOUT;
-        }
-        return timeout;
-    }
-    /**
-     * Resolves sampling rate with validation
-     * Priority: API config > app config > default
-     */
-    static resolveSamplingRate(apiRate, appRate) {
-        const rate = apiRate ?? appRate;
-        if (rate === undefined) {
-            return config_constants_1.DEFAULT_SAMPLING_RATE;
-        }
-        if (rate < config_constants_1.MIN_SAMPLING_RATE || rate > config_constants_1.MAX_SAMPLING_RATE) {
-            logging_1.debugLog.warn('ConfigBuilder', 'Invalid sampling rate, using default', {
-                provided: rate,
-                default: config_constants_1.DEFAULT_SAMPLING_RATE,
-            });
-            return config_constants_1.DEFAULT_SAMPLING_RATE;
-        }
-        return rate;
-    }
-    /**
-     * Resolves error sampling rate based on mode
-     * In debug/qa modes: uses provided value or defaults to full sampling (1.0)
-     * In production: uses provided value or defaults to 10% sampling (0.1)
-     */
-    static resolveErrorSampling(appErrorSampling, apiMode) {
-        const isDebugMode = apiMode === types_1.Mode.DEBUG || apiMode === types_1.Mode.QA;
-        if (isDebugMode) {
-            // In debug mode, respect explicit value or default to full sampling
-            return appErrorSampling ?? 1;
-        }
-        return appErrorSampling ?? 0.1; // Default to 10% sampling in production
-    }
-    /**
-     * Resolves mode with special project ID handling
-     * Priority: Special project ID > API mode > app mode
-     */
-    static resolveMode(appConfig, apiMode) {
-        // Force DEBUG mode for special project IDs
-        if (appConfig.id === types_1.SpecialProjectId.Skip ||
-            appConfig.id === types_1.SpecialProjectId.Fail ||
-            appConfig.id.toLowerCase().startsWith('skip-')) {
-            return types_1.Mode.DEBUG;
-        }
-        // API mode takes precedence over app mode
-        return apiMode ?? appConfig.mode;
-    }
-}
-exports.ConfigBuilder = ConfigBuilder;