@tracelog/lib 0.4.0 → 0.5.0

package/dist/esm/managers/state.manager.js

@@ -1,41 +1,25 @@
 import { debugLog } from '../utils/logging';
 import { DEFAULT_SAMPLING_RATE } from '../constants';
-/**
- * Global state store shared across all TraceLog components
- */
 const globalState = {};
-/**
- * Resets the global state to its initial empty state.
- * Used primarily for testing and cleanup scenarios.
- */
+export function getGlobalState() {
+    return globalState;
+}
 export function resetGlobalState() {
     Object.keys(globalState).forEach((key) => {
         delete globalState[key];
     });
 }
-/**
- * Abstract base class providing state management capabilities to TraceLog components.
- *
- * All managers and handlers extend this class to access and modify the shared global state.
- * State operations are synchronous and thread-safe within the single-threaded browser environment.
- */
 export class StateManager {
-    /**
-     * Gets a value from the global state
-     */
     get(key) {
         return globalState[key];
     }
-    /**
-     * Sets a value in the global state
-     */
     set(key, value) {
         const oldValue = globalState[key];
         if (key === 'config' && value) {
             const configValue = value;
             if (configValue) {
                 const samplingRate = configValue.samplingRate ?? DEFAULT_SAMPLING_RATE;
-                const normalizedSamplingRate = samplingRate > 0 ? samplingRate : DEFAULT_SAMPLING_RATE;
+                const normalizedSamplingRate = samplingRate < 0 || samplingRate > 1 ? DEFAULT_SAMPLING_RATE : samplingRate;
                 const hasNormalizedSampling = normalizedSamplingRate !== samplingRate;
                 if (hasNormalizedSampling) {
                     const normalizedConfig = { ...configValue, samplingRate: normalizedSamplingRate };
@@ -52,7 +36,6 @@ export class StateManager {
         else {
             globalState[key] = value;
         }
-        // Log critical state changes for debugging
         if (this.isCriticalStateKey(key) && this.shouldLog(oldValue, globalState[key])) {
             debugLog.debug('StateManager', 'State updated', {
                 key,
@@ -61,27 +44,15 @@ export class StateManager {
             });
         }
     }
-    /**
-     * Gets the entire state object (for debugging purposes)
-     */
     getState() {
         return { ...globalState };
     }
-    /**
-     * Checks if a state key is considered critical for logging
-     */
     isCriticalStateKey(key) {
         return key === 'sessionId' || key === 'config' || key === 'hasStartSession';
     }
-    /**
-     * Determines if a state change should be logged
-     */
     shouldLog(oldValue, newValue) {
         return oldValue !== newValue;
     }
-    /**
-     * Formats values for logging (avoiding large object dumps)
-     */
     formatLogValue(key, value) {
         if (key === 'config') {
             return value ? '(configured)' : '(not configured)';

package/dist/esm/managers/storage.manager.d.ts

@@ -6,6 +6,7 @@
 export declare class StorageManager {
     private readonly storage;
     private readonly fallbackStorage;
+    private hasQuotaExceededError;
     constructor();
     /**
      * Retrieves an item from storage
@@ -27,6 +28,11 @@ export declare class StorageManager {
      * Checks if storage is available
      */
     isAvailable(): boolean;
+    /**
+     * Checks if a QuotaExceededError has occurred
+     * This indicates localStorage is full and data may not persist
+     */
+    hasQuotaError(): boolean;
     /**
      * Initialize localStorage with feature detection
      */

package/dist/esm/managers/storage.manager.js

@@ -7,6 +7,7 @@ import { debugLog } from '../utils/logging/debug-logger.utils';
 export class StorageManager {
     constructor() {
         this.fallbackStorage = new Map();
+        this.hasQuotaExceededError = false;
         this.storage = this.initializeStorage();
         if (!this.storage) {
             debugLog.warn('StorageManager', 'localStorage not available, using memory fallback');
@@ -38,7 +39,16 @@ export class StorageManager {
             }
         }
         catch (error) {
-            debugLog.warn('StorageManager', 'Failed to set item, using fallback', { key, error });
+            if (error instanceof DOMException && error.name === 'QuotaExceededError') {
+                this.hasQuotaExceededError = true;
+                debugLog.error('StorageManager', 'localStorage quota exceeded - data will not persist after reload', {
+                    key,
+                    valueSize: value.length,
+                });
+            }
+            else {
+                debugLog.warn('StorageManager', 'Failed to set item, using fallback', { key, error });
+            }
         }
         // Always update fallback for consistency
         this.fallbackStorage.set(key, value);
@@ -89,6 +99,13 @@ export class StorageManager {
     isAvailable() {
         return this.storage !== null;
     }
+    /**
+     * Checks if a QuotaExceededError has occurred
+     * This indicates localStorage is full and data may not persist
+     */
+    hasQuotaError() {
+        return this.hasQuotaExceededError;
+    }
     /**
      * Initialize localStorage with feature detection
      */

package/dist/esm/public-api.d.ts

@@ -2,7 +2,7 @@ export * from './app.constants';
 export * from './app.types';
 export declare const tracelog: {
     init: (appConfig: import("./app.types").AppConfig) => Promise<void>;
-    event: (name: string, metadata?: Record<string, import("./app.types").MetadataType>) => void;
+    event: (name: string, metadata?: Record<string, import("./app.types").MetadataType> | Record<string, import("./app.types").MetadataType>[]) => void;
     on: <K extends keyof import("./types").EmitterMap>(event: K, callback: import("./types").EmitterCallback<import("./types").EmitterMap[K]>) => void;
     off: <K extends keyof import("./types").EmitterMap>(event: K, callback: import("./types").EmitterCallback<import("./types").EmitterMap[K]>) => void;
     isInitialized: () => boolean;

package/dist/esm/test-bridge.d.ts

@@ -17,11 +17,12 @@ export declare class TestBridge extends App implements TraceLogTestBridge {
     private _isDestroying;
     constructor(isInitializing: boolean, isDestroying: boolean);
     isInitializing(): boolean;
-    sendCustomEvent(name: string, data?: Record<string, unknown>): void;
+    sendCustomEvent(name: string, data?: Record<string, unknown> | Record<string, unknown>[]): 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(): StorageManager | null;
     getEventManager(): EventManager | null;
@@ -32,7 +33,7 @@ export declare class TestBridge extends App implements TraceLogTestBridge {
     getPerformanceHandler(): PerformanceHandler | null;
     getErrorHandler(): ErrorHandler | null;
     getGoogleAnalytics(): GoogleAnalyticsIntegration | null;
-    destroy(): Promise<void>;
+    destroy(force?: boolean): Promise<void>;
     /**
      * Helper to safely access managers/handlers and convert undefined to null
      */

package/dist/esm/test-bridge.js

@@ -1,5 +1,4 @@
 import { App } from './app';
-import { normalizeConfig } from './utils';
 /**
  * Test bridge for E2E testing
  */
@@ -14,7 +13,10 @@ export class TestBridge extends App {
         return this._isInitializing;
     }
     sendCustomEvent(name, data) {
-        this.ensureInitialized();
+        // Silently ignore events after destroy instead of throwing error
+        if (!this.initialized) {
+            return;
+        }
         super.sendCustomEvent(name, data);
     }
     getSessionData() {
@@ -27,8 +29,7 @@ export class TestBridge extends App {
     setSessionTimeout(timeout) {
         const config = this.get('config');
         if (config) {
-            const { config: normalizedConfig } = normalizeConfig({ ...config, sessionTimeout: timeout });
-            this.set('config', normalizedConfig);
+            this.set('config', { ...config, sessionTimeout: timeout });
         }
     }
     getQueueLength() {
@@ -37,6 +38,29 @@ export class TestBridge extends App {
     forceInitLock(enabled = true) {
         this._isInitializing = enabled;
     }
+    simulatePersistedEvents(events) {
+        const storageManager = this.managers?.storage;
+        if (!storageManager) {
+            throw new Error('Storage manager not available');
+        }
+        const projectId = this.get('config')?.id;
+        const userId = this.get('userId');
+        const sessionId = this.get('sessionId');
+        if (!projectId || !userId) {
+            throw new Error('Project ID or User ID not available. Initialize TraceLog first.');
+        }
+        // Build the persisted data structure matching what SenderManager expects
+        const persistedData = {
+            userId,
+            sessionId: sessionId || `test-session-${Date.now()}`,
+            device: 'desktop',
+            events,
+            timestamp: Date.now(),
+        };
+        // Store in the same format as SenderManager.persistEvents()
+        const storageKey = `tl:${projectId}:queue:${userId}`;
+        storageManager.setItem(storageKey, JSON.stringify(persistedData));
+    }
     get(key) {
         return super.get(key);
     }
@@ -70,12 +94,15 @@ export class TestBridge extends App {
     getGoogleAnalytics() {
         return this.safeAccess(this.integrations?.googleAnalytics);
     }
-    async destroy() {
-        this.ensureInitialized();
+    async destroy(force = false) {
+        // If not initialized and not forcing, silently return (no-op)
+        if (!this.initialized && !force) {
+            return;
+        }
         this.ensureNotDestroying();
         this._isDestroying = true;
         try {
-            await super.destroy();
+            await super.destroy(force);
         }
         finally {
             this._isDestroying = false;

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

@@ -1,9 +1,10 @@
 /**
  * Special project IDs for testing and development
  *
- * Both automatically force mode: 'debug' but differ in HTTP behavior:
+ * All automatically force mode: 'debug' but differ in HTTP behavior:
  * - Skip: NO network calls (pure offline testing)
  * - Localhost: Makes network calls to local server (integration testing)
+ * - Fail: Makes network calls that intentionally fail (persistence testing)
  */
 export declare enum SpecialProjectId {
     /**
@@ -20,17 +21,32 @@ export declare enum SpecialProjectId {
      */
     Skip = "skip",
     /**
-     * Value: 'localhost:' (used as prefix)
+     * Value: 'localhost:8080'
      *
-     * Makes HTTP calls to local development server
-     * Must specify full address: 'localhost:PORT' (e.g., 'localhost:3000')
-     * Converts to http://localhost:PORT/config for requests
+     * Makes HTTP calls to local development server on port 8080
+     * Converts to http://localhost:8080/config for requests
      * Requires origin to be in ALLOWED_ORIGINS list, forces debug mode
      * Perfect for local development with running middleware
      *
      * @example
-     * await TraceLog.init({ id: 'localhost:3000' });
-     * // Makes requests to: http://localhost:3000/config
+     * await TraceLog.init({ id: SpecialProjectId.Localhost });
+     * // or
+     * await TraceLog.init({ id: 'localhost:8080' });
+     * // Makes requests to: http://localhost:8080/config
+     */
+    Localhost = "localhost:8080",
+    /**
+     * Value: 'localhost:9999'
+     *
+     * Makes HTTP calls to non-existent server (port 9999)
+     * All HTTP requests will fail naturally, triggering persistence
+     * Forces debug mode, perfect for testing event persistence & recovery
+     *
+     * @example
+     * await TraceLog.init({ id: SpecialProjectId.Fail });
+     * // or
+     * await TraceLog.init({ id: 'localhost:9999' });
+     * // Makes requests to: http://localhost:9999 (will fail)
      */
-    Localhost = "localhost:"
+    Fail = "localhost:9999"
 }

package/dist/esm/types/api.types.js

@@ -1,9 +1,10 @@
 /**
  * Special project IDs for testing and development
  *
- * Both automatically force mode: 'debug' but differ in HTTP behavior:
+ * All automatically force mode: 'debug' but differ in HTTP behavior:
  * - Skip: NO network calls (pure offline testing)
  * - Localhost: Makes network calls to local server (integration testing)
+ * - Fail: Makes network calls that intentionally fail (persistence testing)
  */
 export var SpecialProjectId;
 (function (SpecialProjectId) {
@@ -21,17 +22,32 @@ export var SpecialProjectId;
      */
     SpecialProjectId["Skip"] = "skip";
     /**
-     * Value: 'localhost:' (used as prefix)
+     * Value: 'localhost:8080'
      *
-     * Makes HTTP calls to local development server
-     * Must specify full address: 'localhost:PORT' (e.g., 'localhost:3000')
-     * Converts to http://localhost:PORT/config for requests
+     * Makes HTTP calls to local development server on port 8080
+     * Converts to http://localhost:8080/config for requests
      * Requires origin to be in ALLOWED_ORIGINS list, forces debug mode
      * Perfect for local development with running middleware
      *
      * @example
-     * await TraceLog.init({ id: 'localhost:3000' });
-     * // Makes requests to: http://localhost:3000/config
+     * await TraceLog.init({ id: SpecialProjectId.Localhost });
+     * // or
+     * await TraceLog.init({ id: 'localhost:8080' });
+     * // Makes requests to: http://localhost:8080/config
+     */
+    SpecialProjectId["Localhost"] = "localhost:8080";
+    /**
+     * Value: 'localhost:9999'
+     *
+     * Makes HTTP calls to non-existent server (port 9999)
+     * All HTTP requests will fail naturally, triggering persistence
+     * Forces debug mode, perfect for testing event persistence & recovery
+     *
+     * @example
+     * await TraceLog.init({ id: SpecialProjectId.Fail });
+     * // or
+     * await TraceLog.init({ id: 'localhost:9999' });
+     * // Makes requests to: http://localhost:9999 (will fail)
      */
-    SpecialProjectId["Localhost"] = "localhost:";
+    SpecialProjectId["Fail"] = "localhost:9999";
 })(SpecialProjectId || (SpecialProjectId = {}));

package/dist/esm/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/esm/types/event.types.js

@@ -18,5 +18,4 @@ export var ErrorType;
 (function (ErrorType) {
     ErrorType["JS_ERROR"] = "js_error";
     ErrorType["PROMISE_REJECTION"] = "promise_rejection";
-    ErrorType["NETWORK_ERROR"] = "network_error";
 })(ErrorType || (ErrorType = {}));

package/dist/esm/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/esm/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/esm/utils/logging/debug-logger.utils.js

@@ -1,7 +1,6 @@
-import { StateManager } from '../../managers/state.manager';
-class DebugLogger extends StateManager {
+import { getGlobalState } from '../../managers/state.manager';
+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);
@@ -11,7 +10,7 @@ class DebugLogger extends 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 = getGlobalState()?.config?.mode;
         if (!this.shouldShow(level, mode))
             return;
         const formattedMsg = `[TraceLog:${ns}] ${msg}`;

package/dist/esm/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/esm/utils/validations/config-validations.utils.js

@@ -1,4 +1,4 @@
-import { DEFAULT_SAMPLING_RATE, MAX_SESSION_TIMEOUT_MS, MIN_SESSION_TIMEOUT_MS, VALIDATION_MESSAGES, } from '../../constants';
+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';
@@ -204,118 +204,6 @@ export const validateAndNormalizeConfig = (config) => {
     }
     return normalizedConfig;
 };
-/**
- * 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 DEFAULT_SAMPLING_RATE;
-    }
-    if (Number.isNaN(samplingRate) || samplingRate <= 0 || samplingRate > 1) {
-        errors.push(VALIDATION_MESSAGES.INVALID_SAMPLING_RATE);
-        return 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
- */
-export 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 < MIN_SESSION_TIMEOUT_MS) {
-            errors.push('sessionTimeout must be at least 30 seconds (30000ms)');
-        }
-        else if (config.sessionTimeout > 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) ?? 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 };
-};
-export const normalizeConfig = (config) => {
-    const { errors, warnings, samplingRate } = validateConfig(config);
-    return {
-        config: {
-            ...config,
-            samplingRate,
-        },
-        errors,
-        warnings,
-    };
-};
-/**
- * Validates the final configuration
- * @param config - The configuration to validate
- * @returns Validation result with errors and warnings
- */
-export const validateFinalConfig = (config) => {
-    const errors = [];
-    const warnings = [];
-    const validatedSamplingRate = validateSamplingRate(config.samplingRate, errors) ?? DEFAULT_SAMPLING_RATE;
-    validateExcludedUrlPaths(config.excludedUrlPaths, errors);
-    // No custom API endpoints supported
-    return { errors, warnings, samplingRate: validatedSamplingRate };
-};
 /**
  * Type guard to check if a JSON response is a valid API config
  * @param json - The JSON to validate
@@ -329,8 +217,11 @@ export const isValidConfigApiResponse = (json) => {
         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),
+                (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/esm/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/esm/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>[];
 };