@tracelog/lib 0.0.8 → 0.2.0

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

@@ -4,256 +4,116 @@ exports.TagsManager = void 0;
 const types_1 = require("../types");
 const state_manager_1 = require("./state.manager");
 class TagsManager extends state_manager_1.StateManager {
+    /**
+     * Gets matching tag IDs for an event based on configured tag conditions
+     */
     getEventTagsIds(event, deviceType) {
-        switch (event.type) {
-            case types_1.EventType.PAGE_VIEW: {
-                return this.checkEventTypePageView(event, deviceType);
-            }
-            case types_1.EventType.CLICK: {
-                return this.checkEventTypeClick(event, deviceType);
-            }
-            default: {
-                return [];
-            }
-        }
-    }
-    checkEventTypePageView(event, deviceType) {
-        const tags = this.get('config')?.tags?.filter((tag) => tag.triggerType === types_1.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 types_1.TagConditionType.URL_MATCHES: {
-                        results.push(this.matchUrlMatches(condition, event.page_url));
-                        break;
-                    }
-                    case types_1.TagConditionType.DEVICE_TYPE: {
-                        results.push(this.matchDeviceType(condition, deviceType));
-                        break;
-                    }
-                    case types_1.TagConditionType.UTM_SOURCE: {
-                        results.push(this.matchUtmCondition(condition, event.utm?.source));
-                        break;
-                    }
-                    case types_1.TagConditionType.UTM_MEDIUM: {
-                        results.push(this.matchUtmCondition(condition, event.utm?.medium));
-                        break;
-                    }
-                    case types_1.TagConditionType.UTM_CAMPAIGN: {
-                        results.push(this.matchUtmCondition(condition, event.utm?.campaign));
-                        break;
-                    }
-                }
-            }
-            let isMatch = false;
-            isMatch = logicalOperator === types_1.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 === types_1.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 types_1.TagConditionType.ELEMENT_MATCHES: {
-                        results.push(this.matchElementSelector(condition, clickData));
-                        break;
-                    }
-                    case types_1.TagConditionType.DEVICE_TYPE: {
-                        results.push(this.matchDeviceType(condition, deviceType));
-                        break;
-                    }
-                    case types_1.TagConditionType.URL_MATCHES: {
-                        results.push(this.matchUrlMatches(condition, event.page_url));
-                        break;
-                    }
-                    case types_1.TagConditionType.UTM_SOURCE: {
-                        results.push(this.matchUtmCondition(condition, event.utm?.source));
-                        break;
-                    }
-                    case types_1.TagConditionType.UTM_MEDIUM: {
-                        results.push(this.matchUtmCondition(condition, event.utm?.medium));
-                        break;
-                    }
-                    case types_1.TagConditionType.UTM_CAMPAIGN: {
-                        results.push(this.matchUtmCondition(condition, event.utm?.campaign));
-                        break;
-                    }
-                }
-            }
-            let isMatch = false;
-            isMatch = logicalOperator === types_1.TagLogicalOperator.AND ? results.every(Boolean) : results.some(Boolean);
-            if (isMatch) {
-                matchedTagIds.push(id);
-            }
-        }
-        return matchedTagIds;
-    }
-    matchUrlMatches(condition, url) {
-        if (condition.type !== types_1.TagConditionType.URL_MATCHES) {
+    /**
+     * Evaluates all conditions for a tag using logical operators
+     */
+    evaluateTagConditions(tag, context) {
+        const { conditions, logicalOperator = types_1.TagLogicalOperator.OR } = tag;
+        if (!conditions || conditions.length === 0) {
             return false;
         }
-        const targetValue = condition.value.toLowerCase();
-        const targetUrl = url.toLowerCase();
-        switch (condition.operator) {
-            case types_1.TagConditionOperator.EQUALS: {
-                return targetUrl === targetValue;
-            }
-            case types_1.TagConditionOperator.CONTAINS: {
-                return targetUrl.includes(targetValue);
-            }
-            case types_1.TagConditionOperator.STARTS_WITH: {
-                return targetUrl.startsWith(targetValue);
-            }
-            case types_1.TagConditionOperator.ENDS_WITH: {
-                return targetUrl.endsWith(targetValue);
-            }
-            case types_1.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 === types_1.TagLogicalOperator.AND ? results.every(Boolean) : results.some(Boolean);
+    }
+    /**
+     * Evaluates a single tag condition
+     */
+    evaluateCondition(condition, context) {
+        try {
+            switch (condition.type) {
+                case types_1.TagConditionType.URL_MATCHES:
+                    return this.matchStringCondition(condition, context.event.page_url);
+                case types_1.TagConditionType.DEVICE_TYPE:
+                    return this.matchStringCondition(condition, context.deviceType);
+                case types_1.TagConditionType.UTM_SOURCE:
+                    return this.matchStringCondition(condition, context.event.utm?.source ?? '');
+                case types_1.TagConditionType.UTM_MEDIUM:
+                    return this.matchStringCondition(condition, context.event.utm?.medium ?? '');
+                case types_1.TagConditionType.UTM_CAMPAIGN:
+                    return this.matchStringCondition(condition, context.event.utm?.campaign ?? '');
+                case types_1.TagConditionType.ELEMENT_MATCHES:
+                    return context.clickData ? this.matchElementCondition(condition, context.clickData) : false;
+                default:
                     return false;
-                }
-            }
-            default: {
-                return false;
             }
         }
-    }
-    matchDeviceType(condition, deviceType) {
-        if (condition.type !== types_1.TagConditionType.DEVICE_TYPE) {
+        catch {
             return false;
         }
-        const targetValue = condition.value.toLowerCase();
-        const targetDevice = deviceType.toLowerCase();
-        switch (condition.operator) {
-            case types_1.TagConditionOperator.EQUALS: {
-                return targetDevice === targetValue;
-            }
-            case types_1.TagConditionOperator.CONTAINS: {
-                return targetDevice.includes(targetValue);
-            }
-            case types_1.TagConditionOperator.STARTS_WITH: {
-                return targetDevice.startsWith(targetValue);
-            }
-            case types_1.TagConditionOperator.ENDS_WITH: {
-                return targetDevice.endsWith(targetValue);
-            }
-            case types_1.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 !== types_1.TagConditionType.ELEMENT_MATCHES) {
+    /**
+     * Unified string matching logic for all string-based conditions
+     */
+    matchStringCondition(condition, value) {
+        if (!value &&
+            condition.operator !== types_1.TagConditionOperator.EXISTS &&
+            condition.operator !== types_1.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 types_1.TagConditionOperator.EQUALS: {
-                return this.checkElementFieldEquals(clickData, targetValue);
-            }
-            case types_1.TagConditionOperator.CONTAINS: {
-                return targetElementData.includes(targetValue);
-            }
-            case types_1.TagConditionOperator.STARTS_WITH: {
-                return targetElementData.startsWith(targetValue);
-            }
-            case types_1.TagConditionOperator.ENDS_WITH: {
-                return targetElementData.endsWith(targetValue);
-            }
-            case types_1.TagConditionOperator.REGEX: {
-                try {
-                    const regex = new RegExp(targetValue, 'gi');
-                    return regex.test(targetElementData);
-                }
-                catch {
-                    return false;
-                }
-            }
-            default: {
+            case types_1.TagConditionOperator.EQUALS:
+                return targetValue === conditionValue;
+            case types_1.TagConditionOperator.CONTAINS:
+                return targetValue.includes(conditionValue);
+            case types_1.TagConditionOperator.STARTS_WITH:
+                return targetValue.startsWith(conditionValue);
+            case types_1.TagConditionOperator.ENDS_WITH:
+                return targetValue.endsWith(conditionValue);
+            case types_1.TagConditionOperator.REGEX:
+                return this.testRegex(conditionValue, targetValue);
+            case types_1.TagConditionOperator.EXISTS:
+                return !!value;
+            case types_1.TagConditionOperator.NOT_EXISTS:
+                return !value;
+            default:
                 return false;
-            }
         }
     }
-    matchUtmCondition(condition, utmValue) {
-        if (![types_1.TagConditionType.UTM_SOURCE, types_1.TagConditionType.UTM_MEDIUM, types_1.TagConditionType.UTM_CAMPAIGN].includes(condition.type)) {
-            return false;
+    /**
+     * Element-specific matching logic with optimized data extraction
+     */
+    matchElementCondition(condition, clickData) {
+        if (condition.operator === types_1.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 types_1.TagConditionOperator.EQUALS: {
-                return targetUtmValue === targetValue;
-            }
-            case types_1.TagConditionOperator.CONTAINS: {
-                return targetUtmValue.includes(targetValue);
-            }
-            case types_1.TagConditionOperator.STARTS_WITH: {
-                return targetUtmValue.startsWith(targetValue);
-            }
-            case types_1.TagConditionOperator.ENDS_WITH: {
-                return targetUtmValue.endsWith(targetValue);
-            }
-            case types_1.TagConditionOperator.REGEX: {
-                try {
-                    const regex = new RegExp(targetValue, 'gi');
-                    return regex.test(targetUtmValue);
-                }
-                catch {
-                    return false;
-                }
-            }
-            default: {
+            case types_1.TagConditionOperator.CONTAINS:
+                return elementData.includes(conditionValue);
+            case types_1.TagConditionOperator.STARTS_WITH:
+                return elementData.startsWith(conditionValue);
+            case types_1.TagConditionOperator.ENDS_WITH:
+                return elementData.endsWith(conditionValue);
+            case types_1.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,
@@ -265,25 +125,47 @@ class TagsManager extends state_manager_1.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;
+        }
+    }
 }
 exports.TagsManager = TagsManager;

package/dist/cjs/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/cjs/managers/user.manager.js

@@ -3,19 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserManager = void 0;
 const constants_1 = require("../constants");
 const utils_1 = require("../utils");
-const state_manager_1 = require("./state.manager");
-class UserManager extends state_manager_1.StateManager {
-    constructor(storageManager) {
-        super();
-        this.storageManager = storageManager;
-    }
-    getId() {
-        const storedUserId = this.storageManager.getItem((0, constants_1.USER_ID_KEY)(this.get('config')?.id));
+/**
+ * Simple utility for managing user identification.
+ * Generates and persists unique user IDs per project.
+ */
+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 = (0, constants_1.USER_ID_KEY)(projectId ?? '');
+        const storedUserId = storageManager.getItem(storageKey);
         if (storedUserId) {
             return storedUserId;
         }
         const newUserId = (0, utils_1.generateUUID)();
-        this.storageManager.setItem((0, constants_1.USER_ID_KEY)(this.get('config')?.id), newUserId);
+        storageManager.setItem(storageKey, newUserId);
         return newUserId;
     }
 }

package/dist/cjs/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/cjs/public-api.js

@@ -10,28 +10,22 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TraceLog = void 0;
-exports.TraceLog = __importStar(require("./api"));
+exports.tracelog = void 0;
+const api_1 = require("./api");
+// Constants
+__exportStar(require("./app.constants"), exports);
+// Types
+__exportStar(require("./app.types"), exports);
+// TraceLog namespace containing all API methods
+exports.tracelog = {
+    init: api_1.init,
+    event: api_1.event,
+    on: api_1.on,
+    off: api_1.off,
+    isInitialized: api_1.isInitialized,
+    destroy: api_1.destroy,
+};

package/dist/cjs/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;
+}