@tracelog/lib 0.0.8 → 0.2.0

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

@@ -1,256 +1,116 @@
-import { EventType, TagConditionOperator, TagConditionType, TagLogicalOperator, } from '../types';
+import { TagConditionOperator, TagConditionType, TagLogicalOperator, } from '../types';
 import { StateManager } from './state.manager';
 export class TagsManager extends StateManager {
+    /**
+     * Gets matching tag IDs for an event based on configured tag conditions
+     */
     getEventTagsIds(event, deviceType) {
-        switch (event.type) {
-            case EventType.PAGE_VIEW: {
-                return this.checkEventTypePageView(event, deviceType);
-            }
-            case EventType.CLICK: {
-                return this.checkEventTypeClick(event, deviceType);
-            }
-            default: {
-                return [];
-            }
-        }
-    }
-    checkEventTypePageView(event, deviceType) {
-        const tags = this.get('config')?.tags?.filter((tag) => tag.triggerType === EventType.PAGE_VIEW) ?? [];
+        const tags = this.get('config')?.tags?.filter((tag) => tag.triggerType === event.type) ?? [];
         if (tags.length === 0) {
             return [];
         }
-        const matchedTagIds = [];
-        for (const tag of tags) {
-            const { id, logicalOperator, conditions } = tag;
-            const results = [];
-            for (const condition of conditions) {
-                switch (condition.type) {
-                    case TagConditionType.URL_MATCHES: {
-                        results.push(this.matchUrlMatches(condition, event.page_url));
-                        break;
-                    }
-                    case TagConditionType.DEVICE_TYPE: {
-                        results.push(this.matchDeviceType(condition, deviceType));
-                        break;
-                    }
-                    case TagConditionType.UTM_SOURCE: {
-                        results.push(this.matchUtmCondition(condition, event.utm?.source));
-                        break;
-                    }
-                    case TagConditionType.UTM_MEDIUM: {
-                        results.push(this.matchUtmCondition(condition, event.utm?.medium));
-                        break;
-                    }
-                    case TagConditionType.UTM_CAMPAIGN: {
-                        results.push(this.matchUtmCondition(condition, event.utm?.campaign));
-                        break;
-                    }
-                }
-            }
-            let isMatch = false;
-            isMatch = logicalOperator === TagLogicalOperator.AND ? results.every(Boolean) : results.some(Boolean);
-            if (isMatch) {
-                matchedTagIds.push(id);
-            }
-        }
-        return matchedTagIds;
+        const context = {
+            event,
+            deviceType,
+            clickData: event.click_data,
+        };
+        return tags.filter((tag) => this.evaluateTagConditions(tag, context)).map((tag) => tag.id);
     }
-    checkEventTypeClick(event, deviceType) {
-        const tags = this.get('config')?.tags?.filter((tag) => tag.triggerType === EventType.CLICK) ?? [];
-        if (tags.length === 0) {
-            return [];
-        }
-        const matchedTagIds = [];
-        for (const tag of tags) {
-            const { id, logicalOperator, conditions } = tag;
-            const results = [];
-            for (const condition of conditions) {
-                if (!event.click_data) {
-                    results.push(false);
-                    continue;
-                }
-                const clickData = event.click_data;
-                switch (condition.type) {
-                    case TagConditionType.ELEMENT_MATCHES: {
-                        results.push(this.matchElementSelector(condition, clickData));
-                        break;
-                    }
-                    case TagConditionType.DEVICE_TYPE: {
-                        results.push(this.matchDeviceType(condition, deviceType));
-                        break;
-                    }
-                    case TagConditionType.URL_MATCHES: {
-                        results.push(this.matchUrlMatches(condition, event.page_url));
-                        break;
-                    }
-                    case TagConditionType.UTM_SOURCE: {
-                        results.push(this.matchUtmCondition(condition, event.utm?.source));
-                        break;
-                    }
-                    case TagConditionType.UTM_MEDIUM: {
-                        results.push(this.matchUtmCondition(condition, event.utm?.medium));
-                        break;
-                    }
-                    case TagConditionType.UTM_CAMPAIGN: {
-                        results.push(this.matchUtmCondition(condition, event.utm?.campaign));
-                        break;
-                    }
-                }
-            }
-            let isMatch = false;
-            isMatch = logicalOperator === TagLogicalOperator.AND ? results.every(Boolean) : results.some(Boolean);
-            if (isMatch) {
-                matchedTagIds.push(id);
-            }
-        }
-        return matchedTagIds;
-    }
-    matchUrlMatches(condition, url) {
-        if (condition.type !== TagConditionType.URL_MATCHES) {
+    /**
+     * Evaluates all conditions for a tag using logical operators
+     */
+    evaluateTagConditions(tag, context) {
+        const { conditions, logicalOperator = TagLogicalOperator.OR } = tag;
+        if (!conditions || conditions.length === 0) {
             return false;
         }
-        const targetValue = condition.value.toLowerCase();
-        const targetUrl = url.toLowerCase();
-        switch (condition.operator) {
-            case TagConditionOperator.EQUALS: {
-                return targetUrl === targetValue;
-            }
-            case TagConditionOperator.CONTAINS: {
-                return targetUrl.includes(targetValue);
-            }
-            case TagConditionOperator.STARTS_WITH: {
-                return targetUrl.startsWith(targetValue);
-            }
-            case TagConditionOperator.ENDS_WITH: {
-                return targetUrl.endsWith(targetValue);
-            }
-            case TagConditionOperator.REGEX: {
-                try {
-                    const regex = new RegExp(targetValue, 'gi');
-                    return regex.test(targetUrl);
-                }
-                catch {
+        const results = conditions.map((condition) => this.evaluateCondition(condition, context));
+        return logicalOperator === TagLogicalOperator.AND ? results.every(Boolean) : results.some(Boolean);
+    }
+    /**
+     * Evaluates a single tag condition
+     */
+    evaluateCondition(condition, context) {
+        try {
+            switch (condition.type) {
+                case TagConditionType.URL_MATCHES:
+                    return this.matchStringCondition(condition, context.event.page_url);
+                case TagConditionType.DEVICE_TYPE:
+                    return this.matchStringCondition(condition, context.deviceType);
+                case TagConditionType.UTM_SOURCE:
+                    return this.matchStringCondition(condition, context.event.utm?.source ?? '');
+                case TagConditionType.UTM_MEDIUM:
+                    return this.matchStringCondition(condition, context.event.utm?.medium ?? '');
+                case TagConditionType.UTM_CAMPAIGN:
+                    return this.matchStringCondition(condition, context.event.utm?.campaign ?? '');
+                case TagConditionType.ELEMENT_MATCHES:
+                    return context.clickData ? this.matchElementCondition(condition, context.clickData) : false;
+                default:
                     return false;
-                }
-            }
-            default: {
-                return false;
             }
         }
-    }
-    matchDeviceType(condition, deviceType) {
-        if (condition.type !== TagConditionType.DEVICE_TYPE) {
+        catch {
             return false;
         }
-        const targetValue = condition.value.toLowerCase();
-        const targetDevice = deviceType.toLowerCase();
-        switch (condition.operator) {
-            case TagConditionOperator.EQUALS: {
-                return targetDevice === targetValue;
-            }
-            case TagConditionOperator.CONTAINS: {
-                return targetDevice.includes(targetValue);
-            }
-            case TagConditionOperator.STARTS_WITH: {
-                return targetDevice.startsWith(targetValue);
-            }
-            case TagConditionOperator.ENDS_WITH: {
-                return targetDevice.endsWith(targetValue);
-            }
-            case TagConditionOperator.REGEX: {
-                try {
-                    const regex = new RegExp(targetValue, 'gi');
-                    return regex.test(targetDevice);
-                }
-                catch {
-                    return false;
-                }
-            }
-            default: {
-                return false;
-            }
-        }
     }
-    matchElementSelector(condition, clickData) {
-        if (condition.type !== TagConditionType.ELEMENT_MATCHES) {
+    /**
+     * Unified string matching logic for all string-based conditions
+     */
+    matchStringCondition(condition, value) {
+        if (!value &&
+            condition.operator !== TagConditionOperator.EXISTS &&
+            condition.operator !== TagConditionOperator.NOT_EXISTS) {
             return false;
         }
-        const elementData = [
-            clickData.id ?? '',
-            clickData.class ?? '',
-            clickData.tag ?? '',
-            clickData.text ?? '',
-            clickData.href ?? '',
-            clickData.title ?? '',
-            clickData.alt ?? '',
-            clickData.role ?? '',
-            clickData.ariaLabel ?? '',
-            ...Object.values(clickData.dataAttributes ?? {}),
-        ].join(' ');
-        const targetValue = condition.value.toLowerCase();
-        const targetElementData = elementData.toLowerCase();
+        const conditionValue = condition.value.toLowerCase();
+        const targetValue = value.toLowerCase();
         switch (condition.operator) {
-            case TagConditionOperator.EQUALS: {
-                return this.checkElementFieldEquals(clickData, targetValue);
-            }
-            case TagConditionOperator.CONTAINS: {
-                return targetElementData.includes(targetValue);
-            }
-            case TagConditionOperator.STARTS_WITH: {
-                return targetElementData.startsWith(targetValue);
-            }
-            case TagConditionOperator.ENDS_WITH: {
-                return targetElementData.endsWith(targetValue);
-            }
-            case TagConditionOperator.REGEX: {
-                try {
-                    const regex = new RegExp(targetValue, 'gi');
-                    return regex.test(targetElementData);
-                }
-                catch {
-                    return false;
-                }
-            }
-            default: {
+            case TagConditionOperator.EQUALS:
+                return targetValue === conditionValue;
+            case TagConditionOperator.CONTAINS:
+                return targetValue.includes(conditionValue);
+            case TagConditionOperator.STARTS_WITH:
+                return targetValue.startsWith(conditionValue);
+            case TagConditionOperator.ENDS_WITH:
+                return targetValue.endsWith(conditionValue);
+            case TagConditionOperator.REGEX:
+                return this.testRegex(conditionValue, targetValue);
+            case TagConditionOperator.EXISTS:
+                return !!value;
+            case TagConditionOperator.NOT_EXISTS:
+                return !value;
+            default:
                 return false;
-            }
         }
     }
-    matchUtmCondition(condition, utmValue) {
-        if (![TagConditionType.UTM_SOURCE, TagConditionType.UTM_MEDIUM, TagConditionType.UTM_CAMPAIGN].includes(condition.type)) {
-            return false;
+    /**
+     * Element-specific matching logic with optimized data extraction
+     */
+    matchElementCondition(condition, clickData) {
+        if (condition.operator === TagConditionOperator.EQUALS) {
+            return this.matchElementFieldExact(condition, clickData);
         }
-        const value = utmValue ?? '';
-        const targetValue = condition.value.toLowerCase();
-        const targetUtmValue = value.toLowerCase();
+        // Build searchable element data string once
+        const elementData = this.buildElementDataString(clickData).toLowerCase();
+        const conditionValue = condition.value.toLowerCase();
         switch (condition.operator) {
-            case TagConditionOperator.EQUALS: {
-                return targetUtmValue === targetValue;
-            }
-            case TagConditionOperator.CONTAINS: {
-                return targetUtmValue.includes(targetValue);
-            }
-            case TagConditionOperator.STARTS_WITH: {
-                return targetUtmValue.startsWith(targetValue);
-            }
-            case TagConditionOperator.ENDS_WITH: {
-                return targetUtmValue.endsWith(targetValue);
-            }
-            case TagConditionOperator.REGEX: {
-                try {
-                    const regex = new RegExp(targetValue, 'gi');
-                    return regex.test(targetUtmValue);
-                }
-                catch {
-                    return false;
-                }
-            }
-            default: {
+            case TagConditionOperator.CONTAINS:
+                return elementData.includes(conditionValue);
+            case TagConditionOperator.STARTS_WITH:
+                return elementData.startsWith(conditionValue);
+            case TagConditionOperator.ENDS_WITH:
+                return elementData.endsWith(conditionValue);
+            case TagConditionOperator.REGEX:
+                return this.testRegex(conditionValue, elementData);
+            default:
                 return false;
-            }
         }
     }
-    checkElementFieldEquals(clickData, targetValue) {
+    /**
+     * Exact field matching for element EQUALS operations
+     */
+    matchElementFieldExact(condition, clickData) {
+        const conditionValue = condition.value.toLowerCase();
         const fields = [
             clickData.id,
             clickData.class,
@@ -262,24 +122,46 @@ export class TagsManager extends StateManager {
             clickData.role,
             clickData.ariaLabel,
         ];
-        for (const field of fields) {
-            if (field) {
-                const fieldValue = field.toLowerCase();
-                const target = targetValue.toLowerCase();
-                if (fieldValue === target) {
-                    return true;
-                }
-            }
+        // Check standard fields
+        if (fields.some((field) => field && field.toLowerCase() === conditionValue)) {
+            return true;
         }
+        // Check data attributes
         if (clickData.dataAttributes) {
-            for (const dataValue of Object.values(clickData.dataAttributes)) {
-                const fieldValue = dataValue.toLowerCase();
-                const target = targetValue.toLowerCase();
-                if (fieldValue === target) {
-                    return true;
-                }
-            }
+            return Object.values(clickData.dataAttributes).some((value) => value.toLowerCase() === conditionValue);
         }
         return false;
     }
+    /**
+     * Builds searchable element data string with null safety
+     */
+    buildElementDataString(clickData) {
+        const parts = [
+            clickData.id,
+            clickData.class,
+            clickData.tag,
+            clickData.text,
+            clickData.href,
+            clickData.title,
+            clickData.alt,
+            clickData.role,
+            clickData.ariaLabel,
+        ].filter(Boolean);
+        if (clickData.dataAttributes) {
+            parts.push(...Object.values(clickData.dataAttributes));
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Safe regex testing with error handling
+     */
+    testRegex(pattern, text) {
+        try {
+            const regex = new RegExp(pattern, 'gi');
+            return regex.test(text);
+        }
+        catch {
+            return false;
+        }
+    }
 }

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

@@ -1,7 +1,16 @@
-import { StateManager } from './state.manager';
 import { StorageManager } from './storage.manager';
-export declare class UserManager extends StateManager {
-    private readonly storageManager;
-    constructor(storageManager: StorageManager);
-    getId(): string;
+/**
+ * Simple utility for managing user identification.
+ * Generates and persists unique user IDs per project.
+ */
+export declare class UserManager {
+    /**
+     * Gets or creates a unique user ID for the given project.
+     * The user ID is persisted in localStorage and reused across sessions.
+     *
+     * @param storageManager - Storage manager instance
+     * @param projectId - Project identifier for namespacing
+     * @returns Persistent unique user ID
+     */
+    static getId(storageManager: StorageManager, projectId?: string): string;
 }

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

@@ -1,18 +1,26 @@
 import { USER_ID_KEY } from '../constants';
 import { generateUUID } from '../utils';
-import { StateManager } from './state.manager';
-export class UserManager extends StateManager {
-    constructor(storageManager) {
-        super();
-        this.storageManager = storageManager;
-    }
-    getId() {
-        const storedUserId = this.storageManager.getItem(USER_ID_KEY(this.get('config')?.id));
+/**
+ * Simple utility for managing user identification.
+ * Generates and persists unique user IDs per project.
+ */
+export class UserManager {
+    /**
+     * Gets or creates a unique user ID for the given project.
+     * The user ID is persisted in localStorage and reused across sessions.
+     *
+     * @param storageManager - Storage manager instance
+     * @param projectId - Project identifier for namespacing
+     * @returns Persistent unique user ID
+     */
+    static getId(storageManager, projectId) {
+        const storageKey = USER_ID_KEY(projectId ?? '');
+        const storedUserId = storageManager.getItem(storageKey);
         if (storedUserId) {
             return storedUserId;
         }
         const newUserId = generateUUID();
-        this.storageManager.setItem(USER_ID_KEY(this.get('config')?.id), newUserId);
+        storageManager.setItem(storageKey, newUserId);
         return newUserId;
     }
 }

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

@@ -1 +1,10 @@
-export * as TraceLog from './api';
+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;
+    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;
+    destroy: () => Promise<void>;
+};

package/dist/esm/public-api.js

@@ -1 +1,14 @@
-export * as TraceLog from './api';
+import { init, event, on, off, isInitialized, destroy } from './api';
+// Constants
+export * from './app.constants';
+// Types
+export * from './app.types';
+// TraceLog namespace containing all API methods
+export const tracelog = {
+    init,
+    event,
+    on,
+    off,
+    isInitialized,
+    destroy,
+};

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

@@ -0,0 +1,48 @@
+import { App } from './app';
+import { ClickHandler } from './handlers/click.handler';
+import { ErrorHandler } from './handlers/error.handler';
+import { PageViewHandler } from './handlers/page-view.handler';
+import { PerformanceHandler } from './handlers/performance.handler';
+import { ScrollHandler } from './handlers/scroll.handler';
+import { SessionHandler } from './handlers/session.handler';
+import { GoogleAnalyticsIntegration } from './integrations/google-analytics.integration';
+import { EventManager } from './managers/event.manager';
+import { StorageManager } from './managers/storage.manager';
+import { State, TraceLogTestBridge } from './types';
+/**
+ * Test bridge for E2E testing
+ */
+export declare class TestBridge extends App implements TraceLogTestBridge {
+    private _isInitializing;
+    private _isDestroying;
+    constructor(isInitializing: boolean, isDestroying: boolean);
+    isInitializing(): boolean;
+    sendCustomEvent(name: string, data?: Record<string, unknown>): void;
+    getSessionData(): Record<string, unknown> | null;
+    setSessionTimeout(timeout: number): void;
+    getQueueLength(): number;
+    forceInitLock(enabled?: boolean): void;
+    get<T extends keyof State>(key: T): State[T];
+    getStorageManager(): StorageManager | null;
+    getEventManager(): EventManager | null;
+    getSessionHandler(): SessionHandler | null;
+    getPageViewHandler(): PageViewHandler | null;
+    getClickHandler(): ClickHandler | null;
+    getScrollHandler(): ScrollHandler | null;
+    getPerformanceHandler(): PerformanceHandler | null;
+    getErrorHandler(): ErrorHandler | null;
+    getGoogleAnalytics(): GoogleAnalyticsIntegration | null;
+    destroy(): Promise<void>;
+    /**
+     * Helper to safely access managers/handlers and convert undefined to null
+     */
+    private safeAccess;
+    /**
+     * Ensures the app is initialized, throws if not
+     */
+    private ensureInitialized;
+    /**
+     * Ensures destroy operation is not in progress, throws if it is
+     */
+    private ensureNotDestroying;
+}

package/dist/esm/test-bridge.js

@@ -0,0 +1,106 @@
+import { App } from './app';
+import { normalizeConfig } from './utils';
+/**
+ * Test bridge for E2E testing
+ */
+export class TestBridge extends App {
+    constructor(isInitializing, isDestroying) {
+        super();
+        this._isDestroying = false;
+        this._isInitializing = isInitializing;
+        this._isDestroying = isDestroying;
+    }
+    isInitializing() {
+        return this._isInitializing;
+    }
+    sendCustomEvent(name, data) {
+        this.ensureInitialized();
+        super.sendCustomEvent(name, data);
+    }
+    getSessionData() {
+        return {
+            id: this.get('sessionId'),
+            isActive: !!this.get('sessionId'),
+            timeout: this.get('config')?.sessionTimeout ?? 15 * 60 * 1000,
+        };
+    }
+    setSessionTimeout(timeout) {
+        const config = this.get('config');
+        if (config) {
+            const { config: normalizedConfig } = normalizeConfig({ ...config, sessionTimeout: timeout });
+            this.set('config', normalizedConfig);
+        }
+    }
+    getQueueLength() {
+        return this.managers.event?.getQueueLength() ?? 0;
+    }
+    forceInitLock(enabled = true) {
+        this._isInitializing = enabled;
+    }
+    get(key) {
+        return super.get(key);
+    }
+    // Manager accessors
+    getStorageManager() {
+        return this.safeAccess(this.managers?.storage);
+    }
+    getEventManager() {
+        return this.safeAccess(this.managers?.event);
+    }
+    // Handler accessors
+    getSessionHandler() {
+        return this.safeAccess(this.handlers?.session);
+    }
+    getPageViewHandler() {
+        return this.safeAccess(this.handlers?.pageView);
+    }
+    getClickHandler() {
+        return this.safeAccess(this.handlers?.click);
+    }
+    getScrollHandler() {
+        return this.safeAccess(this.handlers?.scroll);
+    }
+    getPerformanceHandler() {
+        return this.safeAccess(this.handlers?.performance);
+    }
+    getErrorHandler() {
+        return this.safeAccess(this.handlers?.error);
+    }
+    // Integration accessors
+    getGoogleAnalytics() {
+        return this.safeAccess(this.integrations?.googleAnalytics);
+    }
+    async destroy() {
+        this.ensureInitialized();
+        this.ensureNotDestroying();
+        this._isDestroying = true;
+        try {
+            await super.destroy();
+        }
+        finally {
+            this._isDestroying = false;
+        }
+    }
+    /**
+     * Helper to safely access managers/handlers and convert undefined to null
+     */
+    safeAccess(value) {
+        return value ?? null;
+    }
+    /**
+     * Ensures the app is initialized, throws if not
+     */
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error('App not initialized');
+        }
+    }
+    /**
+     * Ensures destroy operation is not in progress, throws if it is
+     */
+    ensureNotDestroying() {
+        if (this._isDestroying) {
+            throw new Error('Destroy operation already in progress');
+        }
+    }
+}