@selwise/widget 0.0.1

package/dist/npm/esm/datalayer/index.js

@@ -0,0 +1,991 @@
+/**
+ * Data Layer Manager for Selwise Client Widget
+ * Provides GTM-style data layer functionality with window.selwiseLayer
+ */
+import { DEFAULT_CONFIG, DEFAULT_PAGE_PATTERNS, DATA_SOURCE } from './constants.js';
+import { PageTracker } from './page.js';
+import { ProductTracker } from './product.js';
+import { BasketTracker } from './basket.js';
+import { CheckoutTracker } from './checkout.js';
+import { UserTracker } from './user.js';
+import { SearchTracker } from './search.js';
+import { ExternalDataLayerListener } from './listener.js';
+import { CartAssociationTracker } from './cart-association.js';
+import { testModeError, testModeLog } from '../utils/logger.js';
+import { TRACKING_MODULES } from '../modules/contract/tracking-contract.js';
+// Event throttle tracking to prevent duplicate events
+const EVENT_THROTTLE_MAP = new Map();
+const EVENT_THROTTLE_MS = 1000; // 1 second throttle for similar events
+/**
+ * Check if an event should be throttled
+ */
+function shouldThrottleEvent(eventName, entityId) {
+    const key = entityId ? `${eventName}:${entityId}` : eventName;
+    const lastTime = EVENT_THROTTLE_MAP.get(key) || 0;
+    const now = Date.now();
+    if (now - lastTime < EVENT_THROTTLE_MS) {
+        return true;
+    }
+    EVENT_THROTTLE_MAP.set(key, now);
+    return false;
+}
+/**
+ * Generate a throttle key from data layer event data
+ */
+function getEventThrottleKey(data) {
+    if (data.product?.id)
+        return `${data.event}:${data.product.id}`;
+    if (data.basket?.id)
+        return `${data.event}:${data.basket.id}`;
+    if (data.checkout?.orderNo)
+        return `${data.event}:${data.checkout.orderNo}`;
+    if (data.user?.id)
+        return `${data.event}:${data.user.id}`;
+    if (data.search?.query)
+        return `${data.event}:${data.search.query}`;
+    return data.event || 'unknown';
+}
+export class DataLayerManager {
+    constructor(tracker, siteKey, apiUrl, options = {}) {
+        this.isInitialized = false;
+        this.isDestroyed = false;
+        // DOM observation
+        this.observer = null;
+        this.debounceTimer = null;
+        this.lastProcessedIndex = 0;
+        this.originalPush = null;
+        // Last tracked page info for change detection
+        this.lastPageUrl = '';
+        this.lastPageTitle = '';
+        this.consentState = null;
+        this.consentTimeoutTimer = null;
+        this.lastConsentValue = null; // For change detection
+        // Event buffering
+        this.eventBuffer = [];
+        this.flushTimer = null;
+        this.tracker = tracker;
+        this.siteKey = siteKey;
+        this.apiUrl = apiUrl;
+        // Get variable name or use default
+        this.dataLayerName = options.variableName || 'selwiseLayer';
+        const normalizedTrackingModules = this.normalizeTrackingModules(options.trackingModules);
+        const normalizedPageTypePatterns = this.normalizePageTypePatterns(options.pageTypePatterns);
+        // Merge config with defaults
+        this.config = {
+            enabled: options.enabled ?? true,
+            variableName: options.variableName,
+            pageDetection: options.pageDetection ?? 'auto',
+            autoPageTracking: options.autoPageTracking ?? true,
+            cartAbandonmentTimeout: options.cartAbandonmentTimeout ?? 30,
+            pageTypePatterns: normalizedPageTypePatterns,
+            debugMode: options.debugMode ?? false,
+            cookieConsent: options.cookieConsent,
+            trackingModules: normalizedTrackingModules,
+            bufferSize: options.bufferSize ?? 10,
+            flushInterval: options.flushInterval ?? 1000,
+            reverseEventMapping: options.reverseEventMapping,
+            externalDataLayerName: options.externalDataLayerName,
+        };
+        // Store references for quick access
+        this.cookieConsent = options.cookieConsent;
+        this.trackingModules = normalizedTrackingModules;
+        this.log('DataLayerManager constructor called with config:', this.config);
+    }
+    normalizeTrackingModules(modules) {
+        return {
+            page: { ...TRACKING_MODULES.page, ...(modules?.page || {}) },
+            product: { ...TRACKING_MODULES.product, ...(modules?.product || {}) },
+            basket: { ...TRACKING_MODULES.basket, ...(modules?.basket || {}) },
+            checkout: { ...TRACKING_MODULES.checkout, ...(modules?.checkout || {}) },
+            user: { ...TRACKING_MODULES.user, ...(modules?.user || {}) },
+            search: { ...TRACKING_MODULES.search, ...(modules?.search || {}) },
+        };
+    }
+    normalizePageTypePatterns(patterns) {
+        const source = patterns && Object.keys(patterns).length > 0 ? patterns : DEFAULT_PAGE_PATTERNS;
+        const normalized = {};
+        for (const [pageType, pattern] of Object.entries(source)) {
+            if (pattern instanceof RegExp) {
+                normalized[pageType] = pattern;
+                continue;
+            }
+            if (typeof pattern === 'string' && pattern.trim().length > 0) {
+                try {
+                    normalized[pageType] = new RegExp(pattern, 'i');
+                }
+                catch {
+                    this.log(`Invalid regex for page type "${pageType}", using default pattern`);
+                    normalized[pageType] = DEFAULT_PAGE_PATTERNS[pageType] || DEFAULT_PAGE_PATTERNS.home;
+                }
+            }
+        }
+        return Object.keys(normalized).length > 0 ? normalized : { ...DEFAULT_PAGE_PATTERNS };
+    }
+    isModuleEnabled(module) {
+        return Boolean(this.trackingModules?.[module]?.enabled);
+    }
+    shouldAutoTrackPageViews() {
+        if (!this.config.autoPageTracking || !this.pageTracker || !this.isModuleEnabled('page')) {
+            return false;
+        }
+        if (this.config.pageDetection === 'manual') {
+            return false;
+        }
+        if (this.config.pageDetection === 'patterns') {
+            const fullPath = `${window.location.pathname}${window.location.search}`;
+            return Object.values(this.config.pageTypePatterns || {}).some((pattern) => pattern.test(fullPath));
+        }
+        return true;
+    }
+    shouldObservePageChanges() {
+        return (this.shouldAutoTrackPageViews() ||
+            this.isModuleEnabled('product') ||
+            this.isModuleEnabled('checkout'));
+    }
+    /**
+     * Initialize the data layer
+     */
+    init() {
+        if (this.isInitialized) {
+            this.log('DataLayerManager already initialized');
+            return;
+        }
+        if (this.isDestroyed) {
+            this.log('DataLayerManager was destroyed, cannot reinitialize');
+            return;
+        }
+        if (!this.config.enabled) {
+            this.log('Data layer is disabled by config');
+            return;
+        }
+        this.log('Initializing DataLayerManager...');
+        try {
+            // Initialize the data layer array on window
+            this.initializeDataLayer();
+            // Setup push interception
+            this.setupPushInterception();
+            // Setup SPA navigation observer
+            this.setupObserver();
+            // Initialize sub-trackers
+            this.initializeSubTrackers();
+            // Process any existing events in the layer
+            this.processLayer();
+            // Track initial page view based on page detection mode
+            if (this.shouldAutoTrackPageViews()) {
+                this.trackInitialPageView();
+            }
+            // Run auto-detection hooks for product/checkout modules on first load
+            this.runAutomaticModuleTracking();
+            // Expose public API
+            this.exposePublicApi();
+            // Check for abandoned cart on session start
+            this.checkCartAbandonment();
+            // Initialize external data layer listener if reverse mapping is configured
+            this.initExternalListener();
+            // Initialize cookie consent tracking (Phase 8)
+            this.initConsentTracking();
+            this.isInitialized = true;
+            this.log('DataLayerManager initialized successfully');
+        }
+        catch (error) {
+            // Log error but don't crash the entire widget
+            testModeError('DataLayerManager', 'Initialization failed:', error);
+            this.isInitialized = false;
+        }
+    }
+    /**
+     * Initialize the data layer array with configured variable name
+     */
+    initializeDataLayer() {
+        const layerName = this.dataLayerName;
+        // Create the data layer on window with the configured name
+        if (!window[layerName]) {
+            window[layerName] = [];
+            this.log(`Created window.${layerName} array`);
+        }
+        else {
+            this.log(`window.${layerName} already exists, length:`, window[layerName].length);
+        }
+    }
+    /**
+     * Get the data layer array
+     */
+    getDataLayer() {
+        return window[this.dataLayerName] || [];
+    }
+    /**
+     * Setup Array.prototype.push interception to catch data layer pushes
+     */
+    setupPushInterception() {
+        const layer = this.getDataLayer();
+        if (!layer || !layer.push)
+            return;
+        // Store the original push method
+        this.originalPush = layer.push.bind(layer);
+        // Override push to intercept events
+        layer.push = (...items) => {
+            const result = this.originalPush(...items);
+            // Schedule processing of new items
+            this.scheduleProcess();
+            return result;
+        };
+        this.log('Setup push interception');
+    }
+    /**
+     * Setup MutationObserver for SPA navigation detection
+     */
+    setupObserver() {
+        // Observer for detecting page changes in SPAs
+        this.observer = new MutationObserver(() => {
+            if (this.shouldObservePageChanges()) {
+                this.checkPageChange();
+            }
+        });
+        this.observer.observe(document, {
+            childList: true,
+            subtree: true,
+        });
+        // Also listen to History API changes
+        const originalPushState = history.pushState;
+        const originalReplaceState = history.replaceState;
+        history.pushState = (...args) => {
+            originalPushState.apply(history, args);
+            this.onHistoryChange();
+        };
+        history.replaceState = (...args) => {
+            originalReplaceState.apply(history, args);
+            this.onHistoryChange();
+        };
+        // Listen to popstate (back/forward buttons)
+        window.addEventListener('popstate', () => {
+            this.onHistoryChange();
+        });
+        this.log('Setup MutationObserver and History API listeners');
+    }
+    /**
+     * Handle History API changes (SPA navigation)
+     */
+    onHistoryChange() {
+        if (this.shouldObservePageChanges()) {
+            this.checkPageChange();
+        }
+        // Also process any pushed events around navigation.
+        this.scheduleProcess();
+    }
+    /**
+     * Check if page has changed and track new page view
+     */
+    checkPageChange() {
+        const currentUrl = window.location.href;
+        const currentTitle = document.title;
+        if (currentUrl !== this.lastPageUrl || currentTitle !== this.lastPageTitle) {
+            this.log('Page change detected:', currentUrl);
+            if (this.shouldAutoTrackPageViews()) {
+                // Clear throttle for page views to allow tracking
+                EVENT_THROTTLE_MAP.delete('page_view:');
+            }
+            this.lastPageUrl = currentUrl;
+            this.lastPageTitle = currentTitle;
+            // Cleanup dwell time tracking on SPA navigation
+            if (this.productTracker) {
+                this.productTracker.stopDwellTimeTracking();
+            }
+            if (this.shouldAutoTrackPageViews() && this.pageTracker) {
+                this.pageTracker.trackPageView();
+            }
+            this.runAutomaticModuleTracking();
+        }
+    }
+    /**
+     * Initialize all sub-tracker modules based on tracking modules config
+     */
+    initializeSubTrackers() {
+        const commonConfig = {
+            siteKey: this.siteKey,
+            apiUrl: this.apiUrl,
+            tracker: this.tracker,
+            config: this.config,
+            scheduleProcess: () => this.scheduleProcess(),
+        };
+        if (this.isModuleEnabled('page')) {
+            this.pageTracker = new PageTracker(commonConfig);
+            this.log('Page tracker enabled');
+        }
+        if (this.isModuleEnabled('product')) {
+            this.productTracker = new ProductTracker(commonConfig);
+            this.log('Product tracker enabled');
+        }
+        if (this.isModuleEnabled('basket')) {
+            this.basketTracker = new BasketTracker(commonConfig);
+            this.log('Basket tracker enabled');
+        }
+        if (this.isModuleEnabled('checkout')) {
+            this.checkoutTracker = new CheckoutTracker(commonConfig);
+            this.log('Checkout tracker enabled');
+        }
+        if (this.isModuleEnabled('user')) {
+            this.userTracker = new UserTracker(commonConfig);
+            this.log('User tracker enabled');
+        }
+        if (this.isModuleEnabled('search')) {
+            this.searchTracker = new SearchTracker(commonConfig);
+            this.log('Search tracker enabled');
+        }
+        // Cart association tracker follows basket module toggle.
+        if (this.isModuleEnabled('basket')) {
+            this.cartAssociationTracker = new CartAssociationTracker(commonConfig);
+            this.log('Cart association tracker enabled');
+        }
+        this.log('Initialized sub-trackers');
+    }
+    /**
+     * Track the initial page view on load
+     */
+    trackInitialPageView() {
+        this.lastPageUrl = window.location.href;
+        this.lastPageTitle = document.title;
+        if (this.pageTracker) {
+            this.pageTracker.trackPageView();
+        }
+    }
+    /**
+     * Check for abandoned cart on session start
+     */
+    checkCartAbandonment() {
+        if (this.basketTracker) {
+            this.basketTracker.checkCartAbandonment();
+            this.basketTracker.startCartMonitoring();
+        }
+    }
+    runAutomaticModuleTracking() {
+        if (this.checkoutTracker) {
+            this.checkoutTracker.autoTrackCheckoutStep();
+        }
+        if (this.productTracker && this.productTracker.isProductPage()) {
+            this.productTracker.trackProductView();
+        }
+    }
+    /**
+     * Initialize external data layer listener for listening to site's existing dataLayer
+     */
+    initExternalListener() {
+        // Get the reverse mapping from config
+        const reverseMapping = this.config.reverseEventMapping;
+        const externalDataLayerName = this.config.externalDataLayerName || 'dataLayer';
+        if (!reverseMapping || Object.keys(reverseMapping).length === 0) {
+            this.log('No reverse event mapping configured, skipping external listener');
+            return;
+        }
+        try {
+            this.externalListener = new ExternalDataLayerListener({
+                tracker: this.tracker,
+                reverseMapping,
+                dataLayerName: externalDataLayerName,
+                debugMode: this.config.debugMode,
+                enabled: true,
+            });
+            this.externalListener.init();
+            this.log('External dataLayer listener initialized with mapping:', reverseMapping);
+        }
+        catch (error) {
+            this.log('Failed to initialize external dataLayer listener:', error);
+        }
+    }
+    /**
+     * Schedule processing of the data layer
+     */
+    scheduleProcess() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = window.setTimeout(() => {
+            this.processLayer();
+            this.debounceTimer = null;
+        }, DEFAULT_CONFIG.DEBOUNCE_MS);
+    }
+    /**
+     * Process all new events in the data layer
+     */
+    processLayer() {
+        if (this.isDestroyed)
+            return;
+        const layer = this.getDataLayer();
+        if (!layer)
+            return;
+        // Process events from lastProcessedIndex to current length
+        const newEvents = layer.slice(this.lastProcessedIndex);
+        if (newEvents.length === 0)
+            return;
+        this.log('Processing', newEvents.length, 'new data layer events');
+        for (const eventData of newEvents) {
+            this.enqueueEvent(eventData);
+        }
+        this.lastProcessedIndex = layer.length;
+    }
+    enqueueEvent(eventData) {
+        this.eventBuffer.push(eventData);
+        const maxBufferSize = Math.max(1, this.config.bufferSize || 1);
+        const flushIntervalMs = Math.max(100, this.config.flushInterval || 1000);
+        if (this.eventBuffer.length >= maxBufferSize) {
+            this.flushEventBuffer();
+            return;
+        }
+        if (this.flushTimer) {
+            return;
+        }
+        this.flushTimer = window.setTimeout(() => {
+            this.flushEventBuffer();
+        }, flushIntervalMs);
+    }
+    flushEventBuffer() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        if (this.eventBuffer.length === 0) {
+            return;
+        }
+        const eventsToProcess = [...this.eventBuffer];
+        this.eventBuffer = [];
+        for (const eventData of eventsToProcess) {
+            this.processEvent(eventData);
+        }
+    }
+    /**
+     * Check if cookie consent is given
+     * Enhanced with granular consent support (Phase 8)
+     */
+    hasConsent(requiredCategory) {
+        if (!this.cookieConsent?.enabled) {
+            return true; // No consent check required
+        }
+        // Load current consent state
+        const currentConsent = this.loadConsentState();
+        if (!currentConsent) {
+            // No consent state yet
+            const consentVarName = this.cookieConsent.variableName || '__wcmp_consent';
+            const consentValue = window[consentVarName];
+            // Simple consent mode
+            if (consentValue === true || consentValue === 'granted' || consentValue === 1) {
+                return true;
+            }
+            if (this.cookieConsent.defaultConsent && consentValue === undefined) {
+                return true;
+            }
+            this.log('Cookie consent not given, blocking event');
+            return false;
+        }
+        // Granular consent mode
+        if (this.cookieConsent.granularEnabled && requiredCategory) {
+            // Check specific category
+            const hasCategoryConsent = currentConsent[requiredCategory];
+            if (!hasCategoryConsent) {
+                this.log(`Consent denied for category: ${requiredCategory}`);
+            }
+            return hasCategoryConsent;
+        }
+        // Check if analytics category is granted (default for tracking)
+        return currentConsent.analytics || currentConsent.necessary;
+    }
+    /**
+     * Initialize cookie consent tracking with timeout and change detection (Phase 8)
+     */
+    initConsentTracking() {
+        if (!this.cookieConsent?.enabled) {
+            return;
+        }
+        this.log('Initializing cookie consent tracking...');
+        // Load stored consent state
+        this.consentState = this.loadConsentState();
+        // Set up timeout for consent waiting
+        if (this.cookieConsent.waitForConsent && this.cookieConsent.timeoutMs) {
+            this.consentTimeoutTimer = window.setTimeout(() => {
+                this.log('Consent timeout reached, using default consent');
+                if (!this.consentState && this.cookieConsent?.defaultConsent) {
+                    // Apply default consent
+                    this.consentState = {
+                        necessary: true,
+                        analytics: this.cookieConsent.defaultConsent,
+                        marketing: false,
+                        preferences: false,
+                    };
+                }
+                // Process queued and buffered events
+                this.processLayer();
+                this.flushEventBuffer();
+            }, this.cookieConsent.timeoutMs);
+        }
+        // Set up consent change detection
+        this.setupConsentChangeDetection();
+        // Initialize from window variable if available
+        const consentVarName = this.cookieConsent.variableName || '__wcmp_consent';
+        const consentValue = window[consentVarName];
+        if (consentValue !== undefined) {
+            this.updateConsentFromWindow(consentValue);
+        }
+        this.log('Cookie consent tracking initialized');
+    }
+    /**
+     * Setup consent change detection using polling (Phase 8)
+     */
+    setupConsentChangeDetection() {
+        // Check for consent changes every second
+        const checkInterval = setInterval(() => {
+            if (this.isDestroyed) {
+                clearInterval(checkInterval);
+                return;
+            }
+            const consentVarName = this.cookieConsent?.variableName || '__wcmp_consent';
+            const currentConsentValue = window[consentVarName];
+            // Check if consent value changed
+            if (currentConsentValue !== this.lastConsentValue) {
+                this.lastConsentValue = currentConsentValue;
+                this.updateConsentFromWindow(currentConsentValue);
+            }
+            // Also check localStorage for changes
+            const storageKey = this.cookieConsent?.storageKey || 'selwise_consent';
+            const storedConsent = this.loadStoredConsent(storageKey);
+            if (storedConsent) {
+                const oldStateJson = JSON.stringify(this.consentState);
+                this.consentState = storedConsent.granted;
+                const newStateJson = JSON.stringify(this.consentState);
+                if (oldStateJson !== newStateJson) {
+                    this.log('Consent state changed from storage');
+                    this.onConsentChange(storedConsent);
+                }
+            }
+        }, 1000);
+        // Store interval ID for cleanup (not tracked as class property to avoid type issues)
+        this.consentCheckInterval = checkInterval;
+    }
+    /**
+     * Update consent state from window variable (Phase 8)
+     */
+    updateConsentFromWindow(value) {
+        this.log('Updating consent from window variable:', value);
+        if (typeof value === 'boolean') {
+            // Simple consent mode
+            this.consentState = {
+                necessary: true,
+                analytics: value,
+                marketing: value,
+                preferences: value,
+            };
+        }
+        else if (value && typeof value === 'object') {
+            // Granular consent mode
+            this.consentState = {
+                necessary: true, // Always true
+                analytics: value.analytics ?? value.all ?? false,
+                marketing: value.marketing ?? value.all ?? false,
+                preferences: value.preferences ?? value.all ?? false,
+            };
+        }
+        else if (value === 'granted' || value === 1) {
+            this.consentState = {
+                necessary: true,
+                analytics: true,
+                marketing: true,
+                preferences: true,
+            };
+        }
+        else if (value === 'denied' || value === 0) {
+            this.consentState = {
+                necessary: true,
+                analytics: false,
+                marketing: false,
+                preferences: false,
+            };
+        }
+        // Call consent change callback if configured
+        this.callConsentChangeCallback();
+        // Process any buffered events
+        this.processLayer();
+        this.flushEventBuffer();
+    }
+    /**
+     * Load stored consent from localStorage (Phase 8)
+     */
+    loadStoredConsent(storageKey) {
+        try {
+            const stored = localStorage.getItem(storageKey);
+            if (!stored)
+                return null;
+            const parsed = JSON.parse(stored);
+            // Check if expired
+            if (parsed.expiresAt && Date.now() > parsed.expiresAt) {
+                localStorage.removeItem(storageKey);
+                return null;
+            }
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Load consent state from storage or window (Phase 8)
+     */
+    loadConsentState() {
+        if (this.consentState) {
+            return this.consentState;
+        }
+        // Try loading from localStorage
+        const storageKey = this.cookieConsent?.storageKey || 'selwise_consent';
+        const storedConsent = this.loadStoredConsent(storageKey);
+        if (storedConsent) {
+            return storedConsent.granted;
+        }
+        return null;
+    }
+    /**
+     * Handle consent change event (Phase 8)
+     */
+    onConsentChange(consent) {
+        this.log('Consent changed:', consent);
+        // Call user-defined callback if available
+        this.callConsentChangeCallback();
+        // Process any buffered events that may now be allowed
+        this.processLayer();
+        this.flushEventBuffer();
+    }
+    /**
+     * Call user-defined consent change callback (Phase 8)
+     */
+    callConsentChangeCallback() {
+        const callbackName = this.cookieConsent?.consentChangeCallback;
+        if (!callbackName)
+            return;
+        try {
+            const callback = window[callbackName];
+            if (typeof callback === 'function') {
+                callback(this.consentState);
+                this.log(`Called consent change callback: ${callbackName}`);
+            }
+        }
+        catch (error) {
+            this.log('Error calling consent change callback:', error);
+        }
+    }
+    /**
+     * Get current consent state (public API for Phase 8)
+     */
+    getConsentState() {
+        return this.consentState;
+    }
+    /**
+     * Grant consent programmatically (public API for Phase 8)
+     */
+    grantConsent(categories) {
+        this.consentState = {
+            necessary: true,
+            analytics: true,
+            marketing: false,
+            preferences: false,
+            ...categories,
+        };
+        // Store in localStorage
+        const storageKey = this.cookieConsent?.storageKey || 'selwise_consent';
+        const stored = {
+            granted: this.consentState,
+            timestamp: Date.now(),
+            expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000, // 1 year
+        };
+        localStorage.setItem(storageKey, JSON.stringify(stored));
+        this.log('Consent granted:', this.consentState);
+        // Call callback
+        this.callConsentChangeCallback();
+        // Process buffered events
+        this.processLayer();
+        this.flushEventBuffer();
+    }
+    /**
+     * Revoke consent programmatically (public API for Phase 8)
+     */
+    revokeConsent(categories) {
+        if (!this.consentState) {
+            return; // Nothing to revoke
+        }
+        if (categories) {
+            // Revoke specific categories
+            for (const category of categories) {
+                if (category !== 'necessary') {
+                    this.consentState[category] = false;
+                }
+            }
+        }
+        else {
+            // Revoke all except necessary
+            this.consentState.analytics = false;
+            this.consentState.marketing = false;
+            this.consentState.preferences = false;
+        }
+        // Store in localStorage
+        const storageKey = this.cookieConsent?.storageKey || 'selwise_consent';
+        const stored = {
+            granted: this.consentState,
+            timestamp: Date.now(),
+            expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000, // 1 year
+        };
+        localStorage.setItem(storageKey, JSON.stringify(stored));
+        this.log('Consent revoked:', this.consentState);
+        // Call callback
+        this.callConsentChangeCallback();
+    }
+    /**
+     * Process a single data layer event
+     */
+    processEvent(data) {
+        if (!data.event) {
+            this.log('Skipping event without event name:', data);
+            return;
+        }
+        // Check cookie consent before processing
+        if (!this.hasConsent()) {
+            this.log('Event blocked due to cookie consent:', data.event);
+            return;
+        }
+        // Check throttle
+        const throttleKey = getEventThrottleKey(data);
+        if (shouldThrottleEvent(throttleKey)) {
+            this.log('Throttled event:', throttleKey);
+            return;
+        }
+        this.log('Processing event:', data.event);
+        // Route to appropriate tracker based on event type
+        switch (data.event) {
+            // Page events
+            case 'page_view':
+            case 'virtual_page_view':
+                this.pageTracker?.processDataLayer(data);
+                break;
+            // Product events
+            case 'product_view':
+            case 'product_click':
+            case 'product_impression':
+                this.productTracker?.processDataLayer(data);
+                break;
+            // Basket events
+            case 'add_to_cart':
+            case 'remove_from_cart':
+            case 'update_cart':
+            case 'cart_abandon':
+            case 'cart_restore':
+                this.basketTracker?.processDataLayer(data);
+                // Also process through cart association tracker for "added to cart together" analytics
+                this.cartAssociationTracker?.processDataLayer(data);
+                break;
+            // Checkout events
+            case 'checkout_begin':
+            case 'checkout_progress':
+            case 'checkout_option':
+            case 'purchase':
+                this.checkoutTracker?.processDataLayer(data);
+                break;
+            // User events
+            case 'user_signup':
+            case 'user_login':
+            case 'user_logout':
+            case 'user_update':
+                this.userTracker?.processDataLayer(data);
+                break;
+            // Search events
+            case 'search_instant_open':
+            case 'search_query':
+            case 'search_filter':
+            case 'search_sort':
+            case 'search_page':
+            case 'search_results':
+                this.searchTracker?.processDataLayer(data);
+                break;
+            // Custom events
+            case 'custom':
+                this.trackCustomEvent(data);
+                break;
+            default:
+                // Unknown event type - track as custom
+                this.log('Unknown event type, tracking as custom:', data.event);
+                this.trackCustomEvent(data);
+        }
+    }
+    /**
+     * Track a custom event
+     */
+    trackCustomEvent(data) {
+        const eventName = data.custom?.type || data.custom?.name || data.event || 'custom';
+        this.tracker.track(eventName, {
+            entityType: 'custom',
+            entityId: data.custom?.name || undefined,
+            metadata: {
+                dataSource: DATA_SOURCE,
+                pageUrl: window.location.href,
+                referrer: document.referrer,
+                timestamp: Date.now(),
+                ...data.custom?.params,
+                ...data,
+            },
+        });
+    }
+    /**
+     * Expose public API methods to window.Selwise
+     */
+    exposePublicApi() {
+        if (!window.Selwise) {
+            window.Selwise = {};
+        }
+        const layerName = this.dataLayerName;
+        // Manual push method for external scripts
+        window.Selwise.pushDataLayer = (data) => {
+            if (!Array.isArray(window[layerName])) {
+                window[layerName] = [];
+            }
+            window[layerName].push(data);
+        };
+        // Get current data layer state
+        window.Selwise.getDataLayer = () => {
+            return this.getDataLayer();
+        };
+        // Phase 8: Cookie consent API
+        // Get current consent state
+        window.Selwise.getConsentState = () => {
+            return this.getConsentState();
+        };
+        // Grant consent programmatically
+        window.Selwise.grantConsent = (categories) => {
+            this.grantConsent(categories);
+        };
+        // Revoke consent programmatically
+        window.Selwise.revokeConsent = (categories) => {
+            this.revokeConsent(categories);
+        };
+        this.log('Exposed public API');
+    }
+    /**
+     * Update configuration dynamically
+     */
+    updateConfig(options) {
+        if (options.enabled !== undefined) {
+            this.config.enabled = options.enabled;
+        }
+        if (options.variableName !== undefined) {
+            this.config.variableName = options.variableName;
+            this.dataLayerName = options.variableName || 'selwiseLayer';
+        }
+        if (options.pageDetection !== undefined) {
+            this.config.pageDetection = options.pageDetection;
+        }
+        if (options.autoPageTracking !== undefined) {
+            this.config.autoPageTracking = options.autoPageTracking;
+        }
+        if (options.cartAbandonmentTimeout !== undefined) {
+            this.config.cartAbandonmentTimeout = options.cartAbandonmentTimeout;
+        }
+        if (options.pageTypePatterns !== undefined) {
+            this.config.pageTypePatterns = this.normalizePageTypePatterns(options.pageTypePatterns);
+        }
+        if (options.debugMode !== undefined) {
+            this.config.debugMode = options.debugMode;
+        }
+        if (options.cookieConsent !== undefined) {
+            this.config.cookieConsent = options.cookieConsent;
+            this.cookieConsent = options.cookieConsent;
+        }
+        if (options.trackingModules !== undefined) {
+            const normalizedTrackingModules = this.normalizeTrackingModules(options.trackingModules);
+            this.config.trackingModules = normalizedTrackingModules;
+            this.trackingModules = normalizedTrackingModules;
+        }
+        if (options.bufferSize !== undefined) {
+            this.config.bufferSize = options.bufferSize;
+        }
+        if (options.flushInterval !== undefined) {
+            this.config.flushInterval = options.flushInterval;
+        }
+        this.log('Config updated:', this.config);
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Get data layer state (last N events)
+     */
+    getLayerState(maxEvents = 100) {
+        const layer = this.getDataLayer();
+        if (!layer.length)
+            return [];
+        return layer.slice(-maxEvents);
+    }
+    /**
+     * Manually push an event to the data layer
+     */
+    push(data) {
+        if (!Array.isArray(window[this.dataLayerName])) {
+            window[this.dataLayerName] = [];
+        }
+        window[this.dataLayerName].push(data);
+    }
+    /**
+     * Log messages in debug mode or test mode
+     */
+    log(...args) {
+        testModeLog('DataLayerManager', ...args);
+    }
+    /**
+     * Cleanup and destroy the data layer manager
+     */
+    destroy() {
+        this.log('Destroying DataLayerManager...');
+        // Disconnect observer
+        if (this.observer) {
+            this.observer.disconnect();
+            this.observer = null;
+        }
+        // Clear debounce timer
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        // Flush buffered events before shutting down trackers.
+        this.flushEventBuffer();
+        // Clear consent timeout timer (Phase 8)
+        if (this.consentTimeoutTimer) {
+            clearTimeout(this.consentTimeoutTimer);
+            this.consentTimeoutTimer = null;
+        }
+        // Clear consent check interval (Phase 8)
+        const consentCheckInterval = this.consentCheckInterval;
+        if (consentCheckInterval) {
+            clearInterval(consentCheckInterval);
+            this.consentCheckInterval = null;
+        }
+        // Restore original push method on the dynamic layer
+        const layer = this.getDataLayer();
+        if (layer.length && this.originalPush) {
+            window[this.dataLayerName].push = this.originalPush;
+            this.originalPush = null;
+        }
+        // Cleanup sub-trackers
+        this.pageTracker?.destroy();
+        this.productTracker?.destroy();
+        this.basketTracker?.destroy();
+        this.checkoutTracker?.destroy();
+        this.userTracker?.destroy();
+        this.searchTracker?.destroy();
+        this.cartAssociationTracker?.destroy();
+        // Cleanup external data layer listener
+        this.externalListener?.destroy();
+        // Clear throttle map
+        EVENT_THROTTLE_MAP.clear();
+        // Clear event buffer
+        this.eventBuffer = [];
+        this.isDestroyed = true;
+        this.isInitialized = false;
+        this.log('DataLayerManager destroyed');
+    }
+}
+export { ConsentCategory } from './types.js';
+export * from './constants.js';
+//# sourceMappingURL=index.js.map