@tracelog/lib 0.4.0 → 0.5.0

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

@@ -17,8 +17,7 @@ export declare enum ScrollDirection {
 }
 export declare enum ErrorType {
     JS_ERROR = "js_error",
-    PROMISE_REJECTION = "promise_rejection",
-    NETWORK_ERROR = "network_error"
+    PROMISE_REJECTION = "promise_rejection"
 }
 export interface ScrollData {
     depth: number;
@@ -48,7 +47,7 @@ export interface ClickTrackingElementData {
 }
 export interface CustomEventData {
     name: string;
-    metadata?: Record<string, MetadataType>;
+    metadata?: Record<string, MetadataType> | Record<string, MetadataType>[];
 }
 export interface WebVitalsData {
     type: WebVitalType;
@@ -94,7 +93,6 @@ export interface EventData {
     custom_event?: CustomEventData;
     web_vitals?: WebVitalsData;
     page_view?: PageViewData;
-    session_start_recovered?: boolean;
     session_end_reason?: SessionEndReason;
     error_data?: ErrorData;
     utm?: UTM;

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

@@ -21,5 +21,4 @@ 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/test-bridge.types.d.ts

@@ -18,13 +18,14 @@ export interface TraceLogTestBridge {
     init(config: AppConfig): Promise<void>;
     destroy(): Promise<void>;
     isInitializing(): boolean;
-    sendCustomEvent(name: string, data?: Record<string, unknown>): void;
+    sendCustomEvent(name: string, data?: Record<string, unknown> | Record<string, unknown>[]): void;
     on(event: string, callback: (data: any) => void): void;
     off(event: string, callback: (data: any) => void): void;
     getSessionData(): Record<string, unknown> | null;
     setSessionTimeout(timeout: number): void;
     getQueueLength(): number;
     forceInitLock(enabled?: boolean): void;
+    simulatePersistedEvents(events: any[]): void;
     get<T extends keyof State>(key: T): State[T];
     getStorageManager(): TraceLogStorageManager | null;
     getEventManager(): EventManager | null;

package/dist/cjs/utils/logging/debug-logger.utils.d.ts

@@ -1,5 +1,4 @@
-import { StateManager } from '../../managers/state.manager';
-declare class DebugLogger extends StateManager {
+declare class DebugLogger {
     clientError: (ns: string, msg: string, data?: unknown) => void;
     clientWarn: (ns: string, msg: string, data?: unknown) => void;
     info: (ns: string, msg: string, data?: unknown) => void;

package/dist/cjs/utils/logging/debug-logger.utils.js

@@ -2,9 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.debugLog = void 0;
 const state_manager_1 = require("../../managers/state.manager");
-class DebugLogger extends state_manager_1.StateManager {
+class DebugLogger {
     constructor() {
-        super(...arguments);
         this.clientError = (ns, msg, data) => this.log('CLIENT_ERROR', ns, msg, data);
         this.clientWarn = (ns, msg, data) => this.log('CLIENT_WARN', ns, msg, data);
         this.info = (ns, msg, data) => this.log('INFO', ns, msg, data);
@@ -14,7 +13,7 @@ class DebugLogger extends state_manager_1.StateManager {
         this.verbose = (ns, msg, data) => this.log('VERBOSE', ns, msg, data);
     }
     log(level, ns, msg, data) {
-        const mode = this.get('config')?.mode;
+        const mode = (0, state_manager_1.getGlobalState)()?.config?.mode;
         if (!this.shouldShow(level, mode))
             return;
         const formattedMsg = `[TraceLog:${ns}] ${msg}`;

package/dist/cjs/utils/validations/config-validations.utils.d.ts

@@ -1,4 +1,4 @@
-import { AppConfig, Config, ApiConfig } from '../../types';
+import { AppConfig, ApiConfig } from '../../types';
 /**
  * Validates the app configuration object (before normalization)
  * This validates the structure and basic types but allows for normalization afterward
@@ -16,31 +16,6 @@ export declare const validateAppConfig: (config: AppConfig) => void;
  * @throws {AppConfigValidationError} If other configuration validation fails
  */
 export declare const validateAndNormalizeConfig: (config: AppConfig) => AppConfig;
-/**
- * Validates a complete configuration object
- * @param config - The configuration to validate
- * @returns Validation result with errors and warnings
- */
-export declare const validateConfig: (config: Config) => {
-    errors: string[];
-    warnings: string[];
-    samplingRate: number;
-};
-export declare const normalizeConfig: (config: Config) => {
-    config: Config;
-    errors: string[];
-    warnings: string[];
-};
-/**
- * Validates the final configuration
- * @param config - The configuration to validate
- * @returns Validation result with errors and warnings
- */
-export declare const validateFinalConfig: (config: Config) => {
-    errors: string[];
-    warnings: string[];
-    samplingRate: number;
-};
 /**
  * Type guard to check if a JSON response is a valid API config
  * @param json - The JSON to validate

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidConfigApiResponse = exports.validateFinalConfig = exports.normalizeConfig = exports.validateConfig = exports.validateAndNormalizeConfig = exports.validateAppConfig = void 0;
+exports.isValidConfigApiResponse = exports.validateAndNormalizeConfig = exports.validateAppConfig = void 0;
 const constants_1 = require("../../constants");
 const types_1 = require("../../types");
 const validation_error_types_1 = require("../../types/validation-error.types");
@@ -209,121 +209,6 @@ const validateAndNormalizeConfig = (config) => {
     return normalizedConfig;
 };
 exports.validateAndNormalizeConfig = validateAndNormalizeConfig;
-/**
- * Validates sampling rate
- * @param samplingRate - The sampling rate to validate
- * @param errors - Array to push errors to
- */
-const validateSamplingRate = (samplingRate, errors) => {
-    if (samplingRate === undefined) {
-        return undefined;
-    }
-    if (typeof samplingRate !== 'number') {
-        errors.push('samplingRate must be a number');
-        return constants_1.DEFAULT_SAMPLING_RATE;
-    }
-    if (Number.isNaN(samplingRate) || samplingRate <= 0 || samplingRate > 1) {
-        errors.push(constants_1.VALIDATION_MESSAGES.INVALID_SAMPLING_RATE);
-        return constants_1.DEFAULT_SAMPLING_RATE;
-    }
-    return samplingRate;
-};
-/**
- * Validates excluded URL paths
- * @param excludedUrlPaths - The excluded URL paths to validate
- * @param errors - Array to push errors to
- * @param prefix - Optional prefix for error messages
- */
-const validateExcludedUrlPaths = (excludedUrlPaths, errors, prefix = '') => {
-    if (excludedUrlPaths !== undefined) {
-        if (Array.isArray(excludedUrlPaths)) {
-            for (const [index, path] of excludedUrlPaths.entries()) {
-                if (typeof path === 'string') {
-                    try {
-                        new RegExp(path);
-                    }
-                    catch {
-                        errors.push(`${prefix}excludedUrlPaths[${index}] is not a valid regex pattern`);
-                    }
-                }
-                else {
-                    errors.push(`${prefix}excludedUrlPaths[${index}] must be a string`);
-                }
-            }
-        }
-        else {
-            errors.push(`${prefix}excludedUrlPaths must be an array`);
-        }
-    }
-};
-/**
- * Validates a complete configuration object
- * @param config - The configuration to validate
- * @returns Validation result with errors and warnings
- */
-const validateConfig = (config) => {
-    const errors = [];
-    const warnings = [];
-    if (config.sessionTimeout !== undefined) {
-        if (typeof config.sessionTimeout !== 'number') {
-            errors.push('sessionTimeout must be a number');
-        }
-        else if (config.sessionTimeout < constants_1.MIN_SESSION_TIMEOUT_MS) {
-            errors.push('sessionTimeout must be at least 30 seconds (30000ms)');
-        }
-        else if (config.sessionTimeout > constants_1.MAX_SESSION_TIMEOUT_MS) {
-            warnings.push('sessionTimeout is very long (>24 hours), consider reducing it');
-        }
-    }
-    if (config.globalMetadata !== undefined) {
-        if (typeof config.globalMetadata !== 'object' || config.globalMetadata === null) {
-            errors.push('globalMetadata must be an object');
-        }
-        else {
-            const metadataSize = JSON.stringify(config.globalMetadata).length;
-            if (metadataSize > 10240) {
-                errors.push('globalMetadata is too large (max 10KB)');
-            }
-            if (Object.keys(config.globalMetadata).length > 12) {
-                errors.push('globalMetadata has too many keys (max 12)');
-            }
-        }
-    }
-    // No custom API endpoints supported
-    const validatedSamplingRate = validateSamplingRate(config.samplingRate, errors) ?? constants_1.DEFAULT_SAMPLING_RATE;
-    if (config.tags !== undefined && !Array.isArray(config.tags)) {
-        errors.push('tags must be an array');
-    }
-    validateExcludedUrlPaths(config.excludedUrlPaths, errors);
-    return { errors, warnings, samplingRate: validatedSamplingRate };
-};
-exports.validateConfig = validateConfig;
-const normalizeConfig = (config) => {
-    const { errors, warnings, samplingRate } = (0, exports.validateConfig)(config);
-    return {
-        config: {
-            ...config,
-            samplingRate,
-        },
-        errors,
-        warnings,
-    };
-};
-exports.normalizeConfig = normalizeConfig;
-/**
- * Validates the final configuration
- * @param config - The configuration to validate
- * @returns Validation result with errors and warnings
- */
-const validateFinalConfig = (config) => {
-    const errors = [];
-    const warnings = [];
-    const validatedSamplingRate = validateSamplingRate(config.samplingRate, errors) ?? constants_1.DEFAULT_SAMPLING_RATE;
-    validateExcludedUrlPaths(config.excludedUrlPaths, errors);
-    // No custom API endpoints supported
-    return { errors, warnings, samplingRate: validatedSamplingRate };
-};
-exports.validateFinalConfig = validateFinalConfig;
 /**
  * Type guard to check if a JSON response is a valid API config
  * @param json - The JSON to validate
@@ -337,8 +222,11 @@ const isValidConfigApiResponse = (json) => {
         const response = json;
         const result = {
             mode: response['mode'] === undefined || [types_1.Mode.QA, types_1.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),
+                (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',

package/dist/cjs/utils/validations/event-validations.utils.d.ts

@@ -5,8 +5,8 @@ import { MetadataType } from '../../types';
  * @param metadata - Optional metadata to validate
  * @returns Validation result with sanitized metadata if valid
  */
-export declare const isEventValid: (eventName: string, metadata?: Record<string, unknown>) => {
+export declare const isEventValid: (eventName: string, metadata?: Record<string, unknown> | Record<string, unknown>[]) => {
     valid: boolean;
     error?: string;
-    sanitizedMetadata?: Record<string, MetadataType>;
+    sanitizedMetadata?: Record<string, MetadataType> | Record<string, MetadataType>[];
 };

package/dist/cjs/utils/validations/metadata-validations.utils.d.ts

@@ -9,14 +9,14 @@ export declare const isValidEventName: (eventName: string) => {
     error?: string;
 };
 /**
- * Validates metadata for events
+ * Validates metadata for events (supports both objects and arrays of objects)
  * @param eventName - The event name (for error messages)
  * @param metadata - The metadata to validate
  * @param type - Type of metadata (globalMetadata or customEvent)
  * @returns Validation result with sanitized metadata if valid
  */
-export declare const isValidMetadata: (eventName: string, metadata: Record<string, unknown>, type?: "globalMetadata" | "customEvent") => {
+export declare const isValidMetadata: (eventName: string, metadata: Record<string, unknown> | Record<string, unknown>[], type?: "globalMetadata" | "customEvent") => {
     valid: boolean;
     error?: string;
-    sanitizedMetadata?: Record<string, MetadataType>;
+    sanitizedMetadata?: Record<string, MetadataType> | Record<string, MetadataType>[];
 };

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

@@ -45,13 +45,13 @@ const isValidEventName = (eventName) => {
 };
 exports.isValidEventName = isValidEventName;
 /**
- * Validates metadata for events
+ * Validates a single metadata object
  * @param eventName - The event name (for error messages)
- * @param metadata - The metadata to validate
+ * @param metadata - The metadata object to validate
  * @param type - Type of metadata (globalMetadata or customEvent)
  * @returns Validation result with sanitized metadata if valid
  */
-const isValidMetadata = (eventName, metadata, type) => {
+const validateSingleMetadata = (eventName, metadata, type) => {
     const sanitizedMetadata = (0, sanitize_utils_1.sanitizeMetadata)(metadata);
     const intro = type && type === 'customEvent' ? `${type} "${eventName}" metadata error` : `${eventName} metadata error`;
     if (!(0, type_guards_utils_1.isOnlyPrimitiveFields)(sanitizedMetadata)) {
@@ -112,4 +112,42 @@ const isValidMetadata = (eventName, metadata, type) => {
         sanitizedMetadata,
     };
 };
+/**
+ * Validates metadata for events (supports both objects and arrays of objects)
+ * @param eventName - The event name (for error messages)
+ * @param metadata - The metadata to validate
+ * @param type - Type of metadata (globalMetadata or customEvent)
+ * @returns Validation result with sanitized metadata if valid
+ */
+const isValidMetadata = (eventName, metadata, type) => {
+    if (Array.isArray(metadata)) {
+        const sanitizedArray = [];
+        const intro = type && type === 'customEvent' ? `${type} "${eventName}" metadata error` : `${eventName} metadata error`;
+        for (let i = 0; i < metadata.length; i++) {
+            const item = metadata[i];
+            if (typeof item !== 'object' || item === null || Array.isArray(item)) {
+                return {
+                    valid: false,
+                    error: `${intro}: array item at index ${i} must be an object.`,
+                };
+            }
+            const itemValidation = validateSingleMetadata(eventName, item, type);
+            if (!itemValidation.valid) {
+                return {
+                    valid: false,
+                    error: `${intro}: array item at index ${i} is invalid: ${itemValidation.error}`,
+                };
+            }
+            if (itemValidation.sanitizedMetadata) {
+                sanitizedArray.push(itemValidation.sanitizedMetadata);
+            }
+        }
+        // Allow empty arrays after sanitization
+        return {
+            valid: true,
+            sanitizedMetadata: sanitizedArray,
+        };
+    }
+    return validateSingleMetadata(eventName, metadata, type);
+};
 exports.isValidMetadata = isValidMetadata;

package/dist/esm/api.d.ts

@@ -1,60 +1,8 @@
 import { MetadataType, AppConfig, EmitterCallback, EmitterMap } from './types';
 import './types/window.types';
-/**
- * Initializes the tracelog app with the provided configuration.
- * If already initialized, this function returns early without error.
- * @param appConfig - The configuration object for the app
- * @throws {Error} If initialization fails or environment is invalid
- * @example
- * await tracelog.init({ id: 'my-project-id' });
- */
 export declare const init: (appConfig: AppConfig) => Promise<void>;
-/**
- * Sends a custom event with the specified name and metadata.
- * @param name - The name of the custom event.
- * @param metadata - Optional metadata to attach to the event.
- * @example
- * // Send a custom event with metadata
- * tracelog.event('user_signup', { method: 'email', plan: 'premium' });
- * @example
- * // Send a custom event without metadata
- * tracelog.event('user_login');
- * @remarks
- * This function should be called after the app has been initialized using the `tracelog.init` function.
- */
-export declare const event: (name: string, metadata?: Record<string, MetadataType>) => void;
-/**
- * Subscribe to events emitted by TraceLog
- * @param event - Event name to listen to
- * @param callback - Function to call when event is emitted
- * @example
- * // Listen for tracked events
- * tracelog.on('event', (data) => {
- *   console.log('Event tracked:', data.type);
- * });
- *
- * // Listen for event queues being sent
- * tracelog.on('queue', (data) => {
- *   console.log('Events sent:', data.events.length);
- * });
- */
+export declare const event: (name: string, metadata?: Record<string, MetadataType> | Record<string, MetadataType>[]) => void;
 export declare const on: <K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>) => void;
-/**
- * Unsubscribe from events emitted by TraceLog
- * @param event - Event name to stop listening to
- * @param callback - The same function reference that was used in on()
- * @example
- * // Remove a specific listener
- * tracelog.off('event', myCallback);
- */
 export declare const off: <K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>) => void;
-/**
- * Checks if the app has been initialized.
- * @returns true if the app is initialized, false otherwise
- */
 export declare const isInitialized: () => boolean;
-/**
- * Destroys the current app instance and cleans up resources.
- * @throws {Error} If not initialized or already destroying
- */
 export declare const destroy: () => Promise<void>;

package/dist/esm/api.js

@@ -5,29 +5,17 @@ import './types/window.types';
 let app = null;
 let isInitializing = false;
 let isDestroying = false;
-/**
- * Initializes the tracelog app with the provided configuration.
- * If already initialized, this function returns early without error.
- * @param appConfig - The configuration object for the app
- * @throws {Error} If initialization fails or environment is invalid
- * @example
- * await tracelog.init({ id: 'my-project-id' });
- */
 export const init = async (appConfig) => {
-    // Browser environment check
     if (typeof window === 'undefined' || typeof document === 'undefined') {
         throw new Error('This library can only be used in a browser environment');
     }
-    // Check if TraceLog is disabled
     if (window.__traceLogDisabled) {
         return;
     }
-    // Already initialized - safe to return
     if (app) {
         debugLog.debug('API', 'Library already initialized, skipping duplicate initialization');
         return;
     }
-    // Prevent concurrent initialization
     if (isInitializing) {
         debugLog.warn('API', 'Initialization already in progress');
         throw new Error('Initialization already in progress');
@@ -61,19 +49,6 @@ export const init = async (appConfig) => {
         isInitializing = false;
     }
 };
-/**
- * Sends a custom event with the specified name and metadata.
- * @param name - The name of the custom event.
- * @param metadata - Optional metadata to attach to the event.
- * @example
- * // Send a custom event with metadata
- * tracelog.event('user_signup', { method: 'email', plan: 'premium' });
- * @example
- * // Send a custom event without metadata
- * tracelog.event('user_login');
- * @remarks
- * This function should be called after the app has been initialized using the `tracelog.init` function.
- */
 export const event = (name, metadata) => {
     if (!app) {
         throw new Error('TraceLog not initialized. Please call init() first.');
@@ -86,58 +61,25 @@ export const event = (name, metadata) => {
         throw error;
     }
 };
-/**
- * Subscribe to events emitted by TraceLog
- * @param event - Event name to listen to
- * @param callback - Function to call when event is emitted
- * @example
- * // Listen for tracked events
- * tracelog.on('event', (data) => {
- *   console.log('Event tracked:', data.type);
- * });
- *
- * // Listen for event queues being sent
- * tracelog.on('queue', (data) => {
- *   console.log('Events sent:', data.events.length);
- * });
- */
 export const on = (event, callback) => {
     if (!app) {
         throw new Error('TraceLog not initialized. Please call init() first.');
     }
     app.on(event, callback);
 };
-/**
- * Unsubscribe from events emitted by TraceLog
- * @param event - Event name to stop listening to
- * @param callback - The same function reference that was used in on()
- * @example
- * // Remove a specific listener
- * tracelog.off('event', myCallback);
- */
 export const off = (event, callback) => {
     if (!app) {
         throw new Error('TraceLog not initialized. Please call init() first.');
     }
     app.off(event, callback);
 };
-/**
- * Checks if the app has been initialized.
- * @returns true if the app is initialized, false otherwise
- */
 export const isInitialized = () => {
     return app !== null;
 };
-/**
- * Destroys the current app instance and cleans up resources.
- * @throws {Error} If not initialized or already destroying
- */
 export const destroy = async () => {
-    // Check if app was never initialized
     if (!app) {
         throw new Error('App not initialized');
     }
-    // Prevent concurrent destroy operations
     if (isDestroying) {
         throw new Error('Destroy operation already in progress');
     }
@@ -160,7 +102,6 @@ export const destroy = async () => {
         isDestroying = false;
     }
 };
-// Auto-inject testing bridge in development environments
 if (process.env.NODE_ENV === 'dev' && typeof window !== 'undefined') {
     const injectTestingBridge = () => {
         window.__traceLogBridge = new TestBridge(isInitializing, isDestroying);

package/dist/esm/app.constants.d.ts

@@ -2,7 +2,7 @@ export declare const PERFORMANCE_CONFIG: {
     readonly WEB_VITALS_THRESHOLDS: Record<import("./types").WebVitalType, number>;
 };
 export declare const DATA_PROTECTION: {
-    readonly PII_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp];
+    readonly PII_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
 };
 export declare const ENGAGEMENT_THRESHOLDS: {
     readonly LOW_ACTIVITY_EVENT_COUNT: 50;

package/dist/esm/app.d.ts

@@ -9,10 +9,6 @@ import { GoogleAnalyticsIntegration } from './integrations/google-analytics.inte
 import { StorageManager } from './managers/storage.manager';
 import { PerformanceHandler } from './handlers/performance.handler';
 import { ErrorHandler } from './handlers/error.handler';
-/**
- * Main application class for TraceLog analytics
- * Orchestrates event tracking, session management, and integrations
- */
 export declare class App extends StateManager {
     private isInitialized;
     private suppressNextScrollTimer;
@@ -34,7 +30,7 @@ export declare class App extends StateManager {
     };
     get initialized(): boolean;
     init(appConfig: AppConfig): Promise<void>;
-    sendCustomEvent(name: string, metadata?: Record<string, unknown>): void;
+    sendCustomEvent(name: string, metadata?: Record<string, unknown> | Record<string, unknown>[]): void;
     on<K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>): void;
     off<K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>): void;
     destroy(force?: boolean): Promise<void>;

package/dist/esm/app.js

@@ -9,15 +9,11 @@ import { ClickHandler } from './handlers/click.handler';
 import { ScrollHandler } from './handlers/scroll.handler';
 import { EventType } from './types';
 import { GoogleAnalyticsIntegration } from './integrations/google-analytics.integration';
-import { isEventValid, getDeviceType, normalizeUrl, debugLog, Emitter, normalizeConfig } from './utils';
+import { isEventValid, getDeviceType, normalizeUrl, debugLog, Emitter } from './utils';
 import { StorageManager } from './managers/storage.manager';
 import { SCROLL_DEBOUNCE_TIME_MS, SCROLL_SUPPRESS_MULTIPLIER } from './constants/config.constants';
 import { PerformanceHandler } from './handlers/performance.handler';
 import { ErrorHandler } from './handlers/error.handler';
-/**
- * Main application class for TraceLog analytics
- * Orchestrates event tracking, session management, and integrations
- */
 export class App extends StateManager {
     constructor() {
         super(...arguments);
@@ -100,6 +96,7 @@ export class App extends StateManager {
             clearTimeout(this.suppressNextScrollTimer);
             this.suppressNextScrollTimer = null;
         }
+        this.managers.event?.flushImmediatelySync();
         this.managers.event?.stop();
         this.emitter.removeAllListeners();
         this.set('hasStartSession', false);
@@ -109,20 +106,15 @@ export class App extends StateManager {
         this.handlers = {};
     }
     async setupState(appConfig) {
-        // Set API URL
         const apiUrl = getApiUrlForProject(appConfig.id, appConfig.allowHttp);
         this.set('apiUrl', apiUrl);
-        // Get remote configuration
         const configManager = new ConfigManager();
         const config = await configManager.get(apiUrl, appConfig);
-        const { config: normalizedConfig } = normalizeConfig(config);
-        this.set('config', normalizedConfig);
-        // Set user ID
-        const userId = UserManager.getId(this.managers.storage, normalizedConfig.id);
+        this.set('config', config);
+        const userId = UserManager.getId(this.managers.storage, config.id);
         this.set('userId', userId);
-        // Set device and page info
         this.set('device', getDeviceType());
-        const pageUrl = normalizeUrl(window.location.href, normalizedConfig.sensitiveQueryParams);
+        const pageUrl = normalizeUrl(window.location.href, config.sensitiveQueryParams);
         this.set('pageUrl', pageUrl);
     }
     async setupIntegrations() {

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

@@ -1,3 +1,6 @@
-import { ApiConfig, Config } from '../types';
+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;
-export declare const DEFAULT_CONFIG: (config: Config) => Config;

package/dist/esm/constants/api.constants.js

@@ -1,19 +1,11 @@
-import { DEFAULT_SAMPLING_RATE, DEFAULT_SESSION_TIMEOUT, MAX_SAMPLING_RATE, MIN_SAMPLING_RATE, } from './config.constants';
+import { DEFAULT_SAMPLING_RATE } from './config.constants';
+/**
+ * Default API configuration values
+ * Used as fallback when API config is not available or incomplete
+ */
 export const DEFAULT_API_CONFIG = {
     samplingRate: DEFAULT_SAMPLING_RATE,
     excludedUrlPaths: [],
     tags: [],
     ipExcluded: false,
 };
-export const DEFAULT_CONFIG = (config) => ({
-    ...DEFAULT_API_CONFIG,
-    ...config,
-    allowHttp: false,
-    sessionTimeout: DEFAULT_SESSION_TIMEOUT,
-    samplingRate: config.samplingRate && config.samplingRate > MIN_SAMPLING_RATE && config.samplingRate <= MAX_SAMPLING_RATE
-        ? config.samplingRate
-        : DEFAULT_SAMPLING_RATE,
-    excludedUrlPaths: config.excludedUrlPaths ?? [],
-    tags: config.tags ?? [],
-    ipExcluded: config.ipExcluded ?? false,
-});