@selwise/widget 0.0.3 → 1.0.1

package/dist/npm/esm/selwise.js

@@ -1,1129 +0,0 @@
-/**
- * Selwise - Lightweight Embed Script
- * Campaign-Centric Architecture
- * Target: < 15KB gzipped
- */
-import { WidgetRenderer } from './modules/renderer/index.js';
-import { Tracker, ExperimentManager, getConflictResolver, getFrequencyCapManager, evaluatePageTargeting, } from './core/index.js';
-import { deepMergeExperimentConfig, getEffectiveConfig, normalizeContentFields, } from './core/experiment-overrides.js';
-import { SegmentManager } from './core/segments.js';
-import { isTestModeEnabled, resolveApiUrl } from './utils/index.js';
-import { testModeLog, testModeDebug, testModeWarn, testModeError, setDebugMode, } from './utils/logger.js';
-import { initSentryFromConfig, captureException } from './sentry.js';
-import { DataLayerManager } from './datalayer/index.js';
-import { cleanupDeferredRenderers, removeEntityRootsFromDOM, removeEntityRootsById, } from './modules/renderer/utils/helpers.js';
-const defaultModuleLoaders = {
-    loadSearchModule: () => import(
-    /* webpackChunkName: "selwise-search" */
-    './modules/search/index.js'),
-    loadRecommendationModule: () => import(
-    /* webpackChunkName: "selwise-reco" */
-    './modules/recommendation/index.js'),
-};
-export class Selwise {
-    constructor(moduleLoaders = {}) {
-        this.experiments = null;
-        this.segments = null;
-        this.dataLayerManager = null; // Data layer for GTM-style tracking
-        this.searchModule = null; // Dynamically loaded module
-        this.recommendationsCleanup = null; // Cleanup function for recommendations
-        this.recommendationsInitialized = false;
-        this.campaigns = [];
-        this.widgets = [];
-        this.recommendationWidgets = [];
-        this.isDestroyed = false;
-        this.renderedEntities = new Set(); // Track rendered entities to prevent duplicates
-        this.frequencyCapManager = getFrequencyCapManager();
-        this.conflictResolver = getConflictResolver();
-        // Store original History API methods for cleanup
-        this.originalPushState = null;
-        this.originalReplaceState = null;
-        this.popStateListener = null;
-        // Track pending timeouts for cleanup
-        this.pendingTimeouts = new Set();
-        this.spaCleanupSetup = false;
-        this.config = {
-            siteKey: '',
-            apiUrl: resolveApiUrl(),
-        };
-        this.renderer = new WidgetRenderer();
-        this.tracker = new Tracker(this.config.apiUrl, this.config.siteKey);
-        this.moduleLoaders = {
-            ...defaultModuleLoaders,
-            ...moduleLoaders,
-        };
-    }
-    isBrowserEnvironment() {
-        return typeof window !== 'undefined' && typeof document !== 'undefined';
-    }
-    bindGlobalInstance() {
-        if (!this.isBrowserEnvironment())
-            return;
-        try {
-            window.Selwise = this;
-        }
-        catch {
-            // ignore
-        }
-    }
-    clearGlobalInstanceBinding() {
-        if (!this.isBrowserEnvironment())
-            return;
-        try {
-            const globalWindow = window;
-            if (globalWindow.Selwise !== this)
-                return;
-            delete globalWindow.Selwise;
-        }
-        catch {
-            try {
-                if (window.Selwise === this) {
-                    window.Selwise = undefined;
-                }
-            }
-            catch {
-                // ignore
-            }
-        }
-    }
-    // Public getters for external access
-    get siteKey() {
-        return this.config.siteKey || '';
-    }
-    /**
-     * Detect missing browser features
-     * Returns array of missing feature names for graceful degradation
-     */
-    detectMissingFeatures() {
-        const missing = [];
-        // Check for fetch API
-        if (typeof fetch === 'undefined') {
-            missing.push('fetch');
-        }
-        // Check for Promise support
-        if (typeof Promise === 'undefined') {
-            missing.push('Promise');
-        }
-        // Check for IntersectionObserver (used in view tracking)
-        if (typeof IntersectionObserver === 'undefined') {
-            missing.push('IntersectionObserver');
-        }
-        // Check for Map/Set (used for caching)
-        if (typeof Map === 'undefined' || typeof Set === 'undefined') {
-            missing.push('Map/Set');
-        }
-        // Check for MutationObserver (used for SPA navigation)
-        if (typeof MutationObserver === 'undefined') {
-            missing.push('MutationObserver');
-        }
-        // Check for URL/URLSearchParams (used in search)
-        if (typeof URL === 'undefined' || typeof URLSearchParams === 'undefined') {
-            missing.push('URL/URLSearchParams');
-        }
-        return missing;
-    }
-    get apiUrl() {
-        return this.config.apiUrl || '';
-    }
-    get trackingConfig() {
-        return this._trackingConfig || null;
-    }
-    cleanupRenderedEntityRoots() {
-        this.renderedEntities.clear();
-        cleanupDeferredRenderers();
-        removeEntityRootsFromDOM();
-        document.querySelectorAll('[data-widget-id]').forEach((element) => {
-            const htmlElement = element;
-            if (htmlElement.getAttribute('data-selwise-recommendation') === 'true')
-                return;
-            htmlElement.remove();
-        });
-    }
-    cleanupRenderedEntityById(entityId, entityType) {
-        removeEntityRootsById(entityId, entityType);
-        document.querySelectorAll('[data-widget-id]').forEach((element) => {
-            const htmlElement = element;
-            if (htmlElement.dataset.widgetId !== entityId)
-                return;
-            if (htmlElement.getAttribute('data-selwise-recommendation') === 'true')
-                return;
-            htmlElement.remove();
-        });
-    }
-    /**
-     * Setup SPA navigation detection for cleanup
-     * Listens for popstate and detects URL changes
-     *
-     * FIXED: Race condition by reading location.href directly instead of caching
-     */
-    setupSPACleanup() {
-        // Store original History API methods for restoration on destroy
-        this.originalPushState = history.pushState.bind(history);
-        this.originalReplaceState = history.replaceState.bind(history);
-        // Listen for back/forward navigation - store listener for cleanup
-        this.popStateListener = () => {
-            this.onNavigate();
-        };
-        window.addEventListener('popstate', this.popStateListener);
-        // Intercept pushState and replaceState for modern SPAs
-        // Capture URL before and after to detect actual changes
-        history.pushState = (...args) => {
-            const previousUrl = window.location.href;
-            this.originalPushState(...args);
-            const currentUrl = window.location.href;
-            if (previousUrl !== currentUrl) {
-                this.onNavigate();
-            }
-        };
-        history.replaceState = (...args) => {
-            const previousUrl = window.location.href;
-            this.originalReplaceState(...args);
-            const currentUrl = window.location.href;
-            if (previousUrl !== currentUrl) {
-                this.onNavigate();
-            }
-        };
-    }
-    /**
-     * Called when SPA navigation is detected
-     * Cleans up current page resources and re-initializes for new page
-     */
-    onNavigate() {
-        const currentUrl = window.location.href;
-        testModeDebug('Selwise', 'SPA navigation detected:', currentUrl, '- cleaning up...');
-        // Clear any pending timeouts from previous navigation
-        this.pendingTimeouts.forEach((id) => clearTimeout(id));
-        this.pendingTimeouts.clear();
-        // Cleanup search module
-        if (this.searchModule?.destroy) {
-            this.searchModule.destroy();
-            this.searchModule = null;
-        }
-        // Cleanup recommendations module
-        if (this.recommendationsCleanup) {
-            this.recommendationsCleanup();
-            this.recommendationsCleanup = null;
-        }
-        this.recommendationsInitialized = false;
-        // Cleanup rendered campaign/widget roots and pending deferred observers
-        this.cleanupRenderedEntityRoots();
-        // Cleanup tracker state (IntersectionObservers, caches)
-        this.tracker.cleanup();
-        // Cleanup and reinitialize data layer for new page
-        if (this.dataLayerManager) {
-            this.dataLayerManager.destroy();
-            this.dataLayerManager = null;
-        }
-        const dataLayerTimeout = window.setTimeout(() => {
-            this.pendingTimeouts.delete(dataLayerTimeout);
-            this.initDataLayer();
-        }, 50);
-        this.pendingTimeouts.add(dataLayerTimeout);
-        // Cleanup custom scripts
-        document.querySelectorAll('script[data-selwise-script]').forEach((el) => el.remove());
-        document.querySelectorAll('style[data-selwise-script-css]').forEach((el) => el.remove());
-        // Cleanup custom widget JS/CSS
-        document.querySelectorAll('script[data-selwise-custom-js]').forEach((el) => el.remove());
-        document.querySelectorAll('style[data-selwise-custom-css]').forEach((el) => el.remove());
-        // Cleanup product card JS
-        document.querySelectorAll('script[data-selwise-card-js]').forEach((el) => el.remove());
-        // Re-initialize for new page (after a small delay to let DOM settle)
-        const initTimeout = window.setTimeout(() => {
-            this.pendingTimeouts.delete(initTimeout);
-            this.initSearch();
-            this.initRecommendations();
-            this.renderEntitiesWithPolicies().catch((error) => {
-                testModeDebug('Selwise', 'Failed to render entities after navigation:', error);
-            });
-        }, 100);
-        this.pendingTimeouts.add(initTimeout);
-    }
-    /**
-     * Destroy the entire Selwise instance
-     * Call this when completely removing the widget from the page
-     */
-    destroy() {
-        if (this.isDestroyed)
-            return;
-        this.isDestroyed = true;
-        // Clear all pending timeouts
-        this.pendingTimeouts.forEach((id) => clearTimeout(id));
-        this.pendingTimeouts.clear();
-        // Restore original History API methods to prevent memory leaks
-        if (this.originalPushState) {
-            history.pushState = this.originalPushState;
-            this.originalPushState = null;
-        }
-        if (this.originalReplaceState) {
-            history.replaceState = this.originalReplaceState;
-            this.originalReplaceState = null;
-        }
-        if (this.popStateListener) {
-            window.removeEventListener('popstate', this.popStateListener);
-            this.popStateListener = null;
-        }
-        this.spaCleanupSetup = false;
-        // Cleanup search module
-        if (this.searchModule?.destroy) {
-            this.searchModule.destroy();
-        }
-        // Cleanup recommendations module
-        if (this.recommendationsCleanup) {
-            this.recommendationsCleanup();
-        }
-        // Cleanup data layer manager
-        if (this.dataLayerManager) {
-            this.dataLayerManager.destroy();
-        }
-        // Cleanup tracker
-        this.tracker.flush();
-        this.tracker.cleanup();
-        if (this.isBrowserEnvironment()) {
-            this.cleanupRenderedEntityRoots();
-        }
-        this.clearGlobalInstanceBinding();
-        testModeDebug('Selwise', 'Instance destroyed');
-    }
-    async init(config) {
-        if (!this.isBrowserEnvironment()) {
-            testModeWarn('Selwise', 'init() must be called in a browser environment');
-            return;
-        }
-        this.isDestroyed = false;
-        // Feature detection - check for required browser APIs
-        const missingFeatures = this.detectMissingFeatures();
-        if (missingFeatures.length > 0) {
-            testModeWarn('Selwise', 'Browser missing required features:', missingFeatures.join(', '), '- Widget may not function correctly');
-            // Don't completely fail - allow partial functionality
-        }
-        this.config = { ...this.config, ...config };
-        this.tracker = new Tracker(this.config.apiUrl, this.config.siteKey);
-        this.bindGlobalInstance();
-        this.tracker.setupConsentCallback();
-        if (!this.spaCleanupSetup) {
-            this.setupSPACleanup();
-            this.spaCleanupSetup = true;
-        }
-        if (!this.config.siteKey) {
-            testModeWarn('Selwise', 'No site key provided');
-            return;
-        }
-        // Initialize Sentry early - only if explicitly configured
-        // This loads asynchronously from CDN to avoid bundle size impact
-        initSentryFromConfig().catch(() => {
-            // Silently fail - Sentry issues shouldn't block widget initialization
-        });
-        try {
-            // Initialize experiments first to get variants
-            this.experiments = new ExperimentManager(this.config.siteKey, this.tracker.getVisitorId(), this.config.apiUrl);
-            await this.experiments.init();
-            // Initialize segment manager
-            this.segments = new SegmentManager(this.config.apiUrl, this.config.siteKey, this.tracker.getVisitorId(), this.tracker.getSessionId(), this.tracker.getSiteUserId(), this.tracker.getSiteUserProfileId());
-            // PERFORMANCE: Use batch config endpoint for campaigns, widgets, recommendations, and tracking config
-            // This replaces 4 separate requests with 1
-            const [configResult, scriptsResult, integrationsResult] = await Promise.allSettled([
-                this.loadSiteConfig().catch((e) => {
-                    testModeError('Selwise', 'Failed to load site config:', e);
-                    return null;
-                }),
-                this.loadScripts().catch((e) => {
-                    testModeError('Selwise', 'Failed to load scripts:', e);
-                    return null;
-                }),
-                fetch(`${this.config.apiUrl}/public/sites/${this.config.siteKey}/integrations`).catch(() => null),
-            ]);
-            // Process integration configs for reverse event mapping
-            if (integrationsResult.status === 'fulfilled' &&
-                integrationsResult.value &&
-                integrationsResult.value.ok) {
-                const integrations = await integrationsResult.value.json();
-                const reverseMapping = {};
-                // Collect all reverse mappings from enabled integrations
-                for (const integration of integrations.integrations || []) {
-                    const reverseEventMapping = integration.reverseEventMapping || {};
-                    if (integration.enabled && reverseEventMapping) {
-                        Object.assign(reverseMapping, reverseEventMapping);
-                    }
-                }
-                if (Object.keys(reverseMapping).length > 0) {
-                    this.config.reverseEventMapping = reverseMapping;
-                    testModeLog('Selwise', 'Reverse event mapping loaded:', reverseMapping);
-                }
-            }
-            // Process batch config result
-            if (configResult.status === 'fulfilled' && configResult.value) {
-                const { campaigns, widgets, recommendations, tracking } = configResult.value;
-                this.campaigns = campaigns || [];
-                this.widgets = widgets || [];
-                this.recommendationWidgets = recommendations || [];
-                // Apply tracking config from batch endpoint
-                if (tracking) {
-                    this._trackingConfig = tracking;
-                    // Check for subscription requirement
-                    if (tracking.subscriptionRequired) {
-                        testModeWarn('Selwise', 'Subscription required:', tracking.subscriptionMessage);
-                        this.handleSubscriptionInactive(tracking.subscriptionMessage);
-                        return;
-                    }
-                    // Convert flush interval from seconds to milliseconds
-                    const flushIntervalMs = tracking.flushInterval
-                        ? tracking.flushInterval * 1000
-                        : undefined;
-                    // Apply configuration to tracker's batcher
-                    this.tracker.setBatcherConfig({
-                        enabled: tracking.batchingEnabled,
-                        batchSize: tracking.batchSize,
-                        flushInterval: flushIntervalMs,
-                        enablePersistence: tracking.offlinePersistence,
-                        enableSendBeacon: tracking.sendBeaconOnUnload,
-                        maxRetries: tracking.maxRetries,
-                        maxQueueSize: tracking.maxQueueSize,
-                        maxStorageEvents: tracking.maxStorageEvents,
-                        debugMode: tracking.debugMode,
-                    });
-                    // Set global debug mode for logger
-                    setDebugMode(tracking.debugMode || false);
-                    // Initialize the batcher (loads overflow events and flushes them)
-                    await this.tracker.initialize();
-                    // Store data layer config for initialization
-                    this.config.dataLayerConfig = tracking.dataLayerConfig;
-                    if (tracking.debugMode) {
-                        testModeLog('Selwise', 'Tracking config loaded from batch endpoint:', tracking);
-                    }
-                }
-                testModeLog('Selwise', 'Loaded site config from batch endpoint:', {
-                    campaigns: this.campaigns.length,
-                    widgets: this.widgets.length,
-                    recommendations: this.recommendationWidgets.length,
-                });
-                // Initialize data layer (after tracking config is loaded)
-                this.initDataLayer();
-            }
-            else {
-                // Fallback to individual endpoints if batch fails
-                testModeWarn('Selwise', 'Batch endpoint failed, falling back to individual endpoints');
-                this.recommendationWidgets = [];
-                // Fall back to loading tracking config separately
-                await this.loadTrackingConfig();
-                // Initialize data layer (after tracking config is loaded)
-                this.initDataLayer();
-                // Load campaigns and widgets
-                await this.loadCampaignsAndWidgets();
-            }
-            // Render campaigns and widgets immediately using requestIdleCallback for non-blocking execution
-            if ('requestIdleCallback' in window) {
-                requestIdleCallback(() => {
-                    this.renderEntitiesWithPolicies();
-                }, { timeout: 100 }); // Force rendering after 100ms even if idle doesn't fire
-            }
-            else {
-                // Fallback for browsers without requestIdleCallback
-                setTimeout(() => {
-                    this.renderEntitiesWithPolicies();
-                }, 0);
-            }
-            // Initialize search module (lazy loaded) - run in background
-            if ('requestIdleCallback' in window) {
-                requestIdleCallback(() => this.initSearch(), { timeout: 200 });
-            }
-            else {
-                setTimeout(() => this.initSearch(), 50);
-            }
-            // Initialize recommendations module (lazy loaded) - run in background after critical path
-            if ('requestIdleCallback' in window) {
-                requestIdleCallback(() => this.initRecommendations(), { timeout: 300 });
-            }
-            else {
-                setTimeout(() => this.initRecommendations(), 100);
-            }
-        }
-        catch (error) {
-            testModeDebug('Selwise', 'Failed to load data', error);
-            // Send to Sentry if initialized
-            if (error instanceof Error) {
-                captureException(error, { context: 'init' });
-            }
-        }
-    }
-    /**
-     * Fetch and apply tracking configuration from server
-     * This allows dashboard settings to control client-side batching behavior
-     * and data layer configuration
-     */
-    async loadTrackingConfig() {
-        if (!this.config.siteKey || !this.config.apiUrl)
-            return;
-        try {
-            const [trackingResponse, integrationsResponse] = await Promise.allSettled([
-                fetch(`${this.config.apiUrl}/public/sites/${this.config.siteKey}/tracking-config`),
-                fetch(`${this.config.apiUrl}/public/sites/${this.config.siteKey}/integrations`),
-            ]);
-            // Process tracking config
-            if (trackingResponse.status === 'fulfilled' && trackingResponse.value.ok) {
-                const config = await trackingResponse.value.json();
-                // Store full config for external access (e.g., cookie consent widget)
-                this._trackingConfig = config;
-                // Check for subscription requirement
-                if (config.subscriptionRequired) {
-                    testModeWarn('Selwise', 'Subscription required:', config.subscriptionMessage);
-                    this.handleSubscriptionInactive(config.subscriptionMessage);
-                    return; // Stop initialization
-                }
-                // Convert flush interval from seconds to milliseconds
-                const flushIntervalMs = config.flushInterval ? config.flushInterval * 1000 : undefined;
-                // Apply configuration to tracker's batcher
-                this.tracker.setBatcherConfig({
-                    enabled: config.batchingEnabled,
-                    batchSize: config.batchSize,
-                    flushInterval: flushIntervalMs,
-                    enablePersistence: config.offlinePersistence,
-                    enableSendBeacon: config.sendBeaconOnUnload,
-                    maxRetries: config.maxRetries,
-                    maxQueueSize: config.maxQueueSize,
-                    maxStorageEvents: config.maxStorageEvents,
-                    debugMode: config.debugMode,
-                });
-                // Set global debug mode for logger
-                setDebugMode(config.debugMode || false);
-                // Initialize the batcher (loads overflow events and flushes them)
-                await this.tracker.initialize();
-                if (config.debugMode) {
-                    testModeLog('Selwise', 'Tracking config loaded:', config);
-                }
-                // Store data layer config for initialization
-                this.config.dataLayerConfig = config.dataLayerConfig;
-            }
-            else if (trackingResponse.status === 'fulfilled' && trackingResponse.value.status === 403) {
-                // Subscription check failed at HTTP level
-                const error = await trackingResponse.value.json().catch(() => ({}));
-                testModeWarn('Selwise', 'Subscription required (HTTP 403):', error.message || 'Subscription inactive');
-                this.handleSubscriptionInactive(error.message || 'Subscription required');
-                return;
-            }
-            // Process integration configs for reverse event mapping
-            if (integrationsResponse.status === 'fulfilled' && integrationsResponse.value.ok) {
-                const integrations = await integrationsResponse.value.json();
-                const reverseMapping = {};
-                // Collect all reverse mappings from enabled integrations
-                for (const integration of integrations.integrations || []) {
-                    const reverseEventMapping = integration.reverseEventMapping || {};
-                    if (integration.enabled && reverseEventMapping) {
-                        Object.assign(reverseMapping, reverseEventMapping);
-                    }
-                }
-                if (Object.keys(reverseMapping).length > 0) {
-                    this.config.reverseEventMapping = reverseMapping;
-                    testModeLog('Selwise', 'Reverse event mapping loaded:', reverseMapping);
-                }
-            }
-        }
-        catch (error) {
-            // Silently fail, use defaults
-            testModeDebug('Selwise', 'Failed to load tracking config, using defaults');
-        }
-    }
-    /**
-     * Load campaigns, widgets, and recommendations using the batch config endpoint
-     * PERFORMANCE: Single request instead of 3 separate requests
-     * Falls back to individual endpoints if batch endpoint fails
-     */
-    async loadSiteConfig() {
-        if (!this.config.siteKey || !this.config.apiUrl)
-            return null;
-        try {
-            const response = await fetch(`${this.config.apiUrl}/public/sites/${this.config.siteKey}/config`, {
-                method: 'GET',
-            });
-            if (!response.ok) {
-                if (response.status === 403) {
-                    const error = await response.json().catch(() => ({}));
-                    testModeWarn('Selwise', 'Subscription required:', error.message || 'Subscription inactive');
-                    this.handleSubscriptionInactive(error.message || 'Subscription required');
-                }
-                return null;
-            }
-            const data = await response.json();
-            return data;
-        }
-        catch (error) {
-            testModeDebug('Selwise', 'Failed to load batch config, falling back to individual endpoints');
-            return null;
-        }
-    }
-    /**
-     * Fallback path: load campaigns and widgets individually
-     * Used only if batch endpoint fails
-     */
-    async loadCampaignsAndWidgets() {
-        const campaignsPromise = this.loadCampaigns().catch((e) => {
-            testModeError('Selwise', 'Failed to load campaigns:', e);
-            return null;
-        });
-        const widgetsPromise = this.loadWidgets().catch((e) => {
-            testModeError('Selwise', 'Failed to load widgets:', e);
-            return null;
-        });
-        await Promise.allSettled([campaignsPromise, widgetsPromise]);
-    }
-    /**
-     * Initialize the data layer manager
-     * Called after tracking config is loaded to respect server-side settings
-     */
-    initDataLayer() {
-        if (!this.config.siteKey)
-            return;
-        const dlConfig = this.config.dataLayerConfig || {};
-        const reverseMapping = this.config.reverseEventMapping || {};
-        this.dataLayerManager = new DataLayerManager(this.tracker, this.config.siteKey, resolveApiUrl(this.config.apiUrl), {
-            enabled: dlConfig.enabled ?? true, // Enabled by default for comprehensive event tracking
-            variableName: dlConfig.variableName ?? 'selwiseLayer',
-            pageDetection: dlConfig.pageDetection ?? 'auto',
-            autoPageTracking: dlConfig.autoPageTracking ?? true,
-            cartAbandonmentTimeout: dlConfig.cartAbandonmentTimeout ?? 30,
-            pageTypePatterns: dlConfig.pageTypePatterns ?? undefined,
-            debugMode: dlConfig.debugMode ?? false,
-            cookieConsent: dlConfig.cookieConsent,
-            trackingModules: dlConfig.trackingModules,
-            bufferSize: dlConfig.bufferSize,
-            flushInterval: dlConfig.flushInterval,
-            reverseEventMapping: Object.keys(reverseMapping).length > 0 ? reverseMapping : undefined,
-            externalDataLayerName: 'dataLayer',
-        });
-        // Initialize if enabled (enabled by default)
-        if (dlConfig.enabled ?? true) {
-            this.dataLayerManager.init();
-            testModeLog('Selwise', 'Data layer manager initialized and started');
-        }
-        else {
-            testModeLog('Selwise', 'Data layer manager created but NOT enabled (disabled in dashboard settings)');
-        }
-        if (dlConfig.debugMode) {
-            testModeLog('Selwise', 'Data layer initialized with config:', dlConfig);
-        }
-    }
-    /**
-     * Public helper for experiment variant access
-     * Returns the full variant assignment for an experiment
-     */
-    getVariant(experimentId) {
-        return this.experiments?.getVariant(experimentId);
-    }
-    /**
-     * Public helper for getting the assigned variant ID
-     * Returns just the variant ID (e.g., 'variant_a', 'control')
-     */
-    getExperimentVariant(experimentId) {
-        if (!this.experiments)
-            return null;
-        return this.experiments.getAssignedVariant(experimentId);
-    }
-    /**
-     * Public helper for getting all active experiment assignments
-     * Returns an array of all experiment assignments for the current visitor
-     */
-    getActiveExperiments() {
-        if (!this.experiments)
-            return [];
-        return this.experiments.getAllAssignments();
-    }
-    /**
-     * Public helper for purchase/order tracking.
-     * Merchants can call: window.Selwise.trackOrder({...})
-     */
-    async trackOrder(order) {
-        return this.tracker.trackOrder(order);
-    }
-    /**
-     * Identify a user.
-     * Call this when a user logs in or is identified.
-     * @param userId Unique user ID from your system
-     * @param metadata Optional metadata about the user
-     * @returns Promise with success status and merge indicator
-     */
-    async identify(userId, metadata) {
-        if (!userId)
-            return { success: false, merged: false };
-        const result = await this.tracker.identify(userId, metadata);
-        // Update segment manager with new user identifiers for accurate evaluation
-        if (this.segments) {
-            this.segments.updateUserIdentifiers(this.tracker.getSiteUserId(), this.tracker.getSiteUserProfileId());
-        }
-        return result;
-    }
-    /**
-     * Set user traits without changing identity.
-     * Call this to update user attributes like name, email, plan, etc.
-     * @param traits Key-value pairs of user attributes
-     * @returns Promise with success status
-     */
-    async setTraits(traits) {
-        return this.tracker.setTraits(traits);
-    }
-    /**
-     * Track a custom event.
-     * Call this to track custom events like 'button_clicked', 'form_submitted', etc.
-     * @param name Event name (e.g., 'product_viewed', 'button_clicked')
-     * @param args Optional event data including entityType, entityId, and metadata
-     *
-     * @example
-     * window.Selwise.track('product_viewed', {
-     *   entityType: 'product',
-     *   entityId: 'prod_123',
-     *   metadata: { price: 99.99, category: 'electronics' }
-     * })
-     */
-    track(name, args) {
-        return this.tracker.track(name, args);
-    }
-    /**
-     * Get current site user ID (if user has been identified)
-     * @returns The site user ID or undefined
-     */
-    getSiteUserId() {
-        return this.tracker.getSiteUserId();
-    }
-    /**
-     * Get current visitor ID
-     * @returns The visitor ID
-     */
-    getVisitorId() {
-        return this.tracker.getVisitorId();
-    }
-    /**
-     * Get current session ID
-     * @returns The session ID
-     */
-    getSessionId() {
-        return this.tracker.getSessionId();
-    }
-    /**
-     * Get current journey ID
-     * @returns The journey ID or null if no active journey
-     */
-    getJourneyId() {
-        return this.tracker.getJourneyId();
-    }
-    /**
-     * Get current journey state for debugging
-     * @returns Journey state including ID, age, and validity
-     */
-    getJourneyState() {
-        return this.tracker.getJourneyState();
-    }
-    /**
-     * End the current journey
-     * Clears the journey ID and starts a new one on the next event
-     */
-    endJourney() {
-        this.tracker.endJourney();
-    }
-    /**
-     * Search module - dynamically imported for code splitting
-     */
-    async initSearch() {
-        try {
-            const { SearchModule } = await this.moduleLoaders.loadSearchModule();
-            this.searchModule = new SearchModule(this.config.apiUrl, this.config.siteKey, this.experiments ?? undefined, this.segments ?? undefined);
-            await this.searchModule.init();
-        }
-        catch (error) {
-            testModeDebug('Selwise', 'Search module initialization failed', error);
-        }
-    }
-    /**
-     * Recommendations module - dynamically imported for code splitting
-     */
-    async initRecommendations() {
-        if (this.recommendationsInitialized)
-            return;
-        try {
-            const { initRecommendations, cleanup } = await this.moduleLoaders.loadRecommendationModule();
-            await initRecommendations({
-                siteKey: this.config.siteKey,
-                apiEndpoint: this.config.apiUrl,
-                experimentManager: this.experiments ?? undefined,
-                segmentManager: this.segments ?? undefined,
-                widgets: this.recommendationWidgets,
-            });
-            this.recommendationsInitialized = true;
-            this.recommendationsCleanup = cleanup; // Store cleanup function
-            testModeLog('Selwise', 'Recommendations module initialized');
-        }
-        catch (error) {
-            testModeDebug('Selwise', 'Recommendations module initialization failed', error);
-        }
-    }
-    async loadCampaigns() {
-        const response = await fetch(`${this.config.apiUrl}/public/sites/${this.config.siteKey}/campaigns`, {
-            method: 'GET',
-        });
-        if (!response.ok) {
-            if (response.status === 403) {
-                const error = await response.json().catch(() => ({}));
-                testModeWarn('Selwise', 'Subscription required for campaigns:', error.message || 'Subscription inactive');
-                this.handleSubscriptionInactive(error.message || 'Subscription required');
-            }
-            throw new Error('Failed to fetch campaigns');
-        }
-        const data = await response.json();
-        this.campaigns = data.campaigns || [];
-    }
-    async loadWidgets() {
-        const response = await fetch(`${this.config.apiUrl}/public/sites/${this.config.siteKey}/widgets`, {
-            method: 'GET',
-        });
-        if (!response.ok) {
-            if (response.status === 403) {
-                const error = await response.json().catch(() => ({}));
-                testModeWarn('Selwise', 'Subscription required for widgets:', error.message || 'Subscription inactive');
-                this.handleSubscriptionInactive(error.message || 'Subscription required');
-            }
-            // Silently fail when endpoint is unavailable
-            return;
-        }
-        const data = await response.json();
-        this.widgets = data.widgets || [];
-    }
-    async loadScripts() {
-        const currentPath = window.location.pathname;
-        try {
-            const response = await fetch(`${this.config.apiUrl}/public/sites/${this.config.siteKey}/scripts?path=${encodeURIComponent(currentPath)}`, {
-                method: 'GET',
-            });
-            if (!response.ok) {
-                testModeDebug('Selwise', 'Failed to fetch scripts');
-                return;
-            }
-            const data = await response.json();
-            const scripts = data.scripts || [];
-            testModeLog('Selwise', 'Loading custom scripts:', scripts.length);
-            scripts.forEach((script) => {
-                try {
-                    // Inject CSS first if provided
-                    if (script.css) {
-                        const styleElement = document.createElement('style');
-                        styleElement.setAttribute('data-selwise-script-css', script.id);
-                        styleElement.textContent = script.css;
-                        document.head.appendChild(styleElement);
-                        testModeLog('Selwise', `Injected script CSS: ${script.name}`);
-                    }
-                    // Create and execute the script
-                    const scriptElement = document.createElement('script');
-                    scriptElement.setAttribute('data-selwise-script', script.id);
-                    scriptElement.textContent = script.code;
-                    document.body.appendChild(scriptElement);
-                    testModeLog('Selwise', `Injected script: ${script.name}`);
-                    this.tracker.track('script_injected', {
-                        entityType: 'script',
-                        entityId: script.id,
-                        metadata: { name: script.name },
-                    });
-                }
-                catch (error) {
-                    testModeError('Selwise', `Failed to execute script: ${script.name}`);
-                    testModeDebug('Selwise', 'Script execution error details:', error);
-                    if (error instanceof SyntaxError) {
-                        testModeWarn('Selwise', 'Script syntax error. Please check for invalid characters or escapes.');
-                    }
-                    try {
-                        this.tracker.track('script_error', {
-                            entityType: 'script',
-                            entityId: script.id,
-                            metadata: {
-                                name: script.name,
-                                message: error?.message,
-                            },
-                        });
-                    }
-                    catch {
-                        // ignore
-                    }
-                }
-            });
-        }
-        catch (error) {
-            testModeDebug('Selwise', 'Failed to load scripts', error);
-        }
-    }
-    shouldRenderForCurrentPage(entity, type) {
-        const shouldRender = evaluatePageTargeting(entity.pageTargetingJson, window.location.href);
-        if (!shouldRender) {
-            testModeLog('Selwise', `Skipping ${type} due to page targeting: ${entity.id}`);
-        }
-        return shouldRender;
-    }
-    buildDisplayCandidates() {
-        const allEntities = [
-            ...this.campaigns.map((campaign) => ({ entity: campaign, type: 'campaign' })),
-            ...this.widgets.map((widget) => ({ entity: widget, type: 'widget' })),
-        ];
-        return allEntities
-            .filter(({ entity, type }) => this.shouldRenderForCurrentPage(entity, type))
-            .map(({ entity, type }) => {
-            const placementConfig = (entity.placementConfigJson || {});
-            const selector = placementConfig.selector;
-            const placementPosition = placementConfig.position || placementConfig.insertPosition;
-            const conflictResolution = placementConfig.conflictResolution || {};
-            const candidate = this.conflictResolver.applyConfig({
-                id: `${type}:${entity.id}`,
-                type,
-                selector,
-                placementPosition,
-                priority: entity.priority ?? conflictResolution.priority,
-                conflictBehavior: conflictResolution.behavior,
-                placementConfigJson: placementConfig,
-            });
-            return {
-                id: candidate.id,
-                type,
-                priority: candidate.priority,
-                conflictBehavior: candidate.conflictBehavior,
-                selector: candidate.selector,
-                placementPosition: candidate.placementPosition,
-                placementConfigJson: placementConfig,
-                sourceId: entity.id,
-                sourceEntity: entity,
-                frequencyCapConfig: placementConfig.frequencyCap,
-            };
-        });
-    }
-    async renderEntitiesWithPolicies() {
-        const candidates = this.buildDisplayCandidates();
-        testModeLog('Selwise', 'Rendering entities with policies:', candidates.length);
-        this.renderedEntities.clear();
-        this.frequencyCapManager.cleanup();
-        if (candidates.length === 0)
-            return;
-        const resolutionResults = this.conflictResolver.resolveAll(candidates);
-        const selectedIds = new Set(resolutionResults.flatMap((result) => result.selected.map((candidate) => candidate.id)));
-        for (const candidate of candidates) {
-            if (!selectedIds.has(candidate.id)) {
-                continue;
-            }
-            const frequencyKey = `display:${candidate.id}`;
-            if (candidate.frequencyCapConfig) {
-                const check = this.frequencyCapManager.canShow(frequencyKey, candidate.frequencyCapConfig);
-                if (!check.allowed) {
-                    testModeLog('Selwise', `Skipping ${candidate.type} due to frequency cap (${check.reason || 'limit'}):`, candidate.sourceId);
-                    continue;
-                }
-            }
-            const rendered = await this.renderEntity(candidate.sourceEntity, candidate.type);
-            if (rendered && candidate.frequencyCapConfig) {
-                this.frequencyCapManager.recordShown(frequencyKey);
-            }
-        }
-    }
-    /**
-     * Unified entity rendering for campaigns and widgets
-     * @param skipVariantCheck - Skip variant module lookup (used when rendering variant modules to prevent infinite loops)
-     */
-    async renderEntity(entity, type, skipVariantCheck = false) {
-        const testModeEnabled = isTestModeEnabled();
-        const entityName = type === 'campaign' ? 'campaign' : 'widget';
-        // Skip if already rendered (prevents duplicate rendering when both control and variant are in the list)
-        if (this.renderedEntities.has(entity.id)) {
-            testModeLog('Selwise', `Skipping already rendered ${entityName}: ${entity.id}`);
-            return false;
-        }
-        // Skip test mode entities if test mode is not enabled
-        if (entity.isTestMode && !testModeEnabled) {
-            testModeWarn('Selwise', `Skipping test mode ${entityName}: ${entity.id}${type === 'campaign' ? " (Run localStorage.setItem('selwise_test_mode', 'true') to view)" : ''}`);
-            return false;
-        }
-        // Re-check page targeting at render time to avoid stale route races.
-        if (!this.shouldRenderForCurrentPage(entity, type)) {
-            return false;
-        }
-        // Check for different_module mode experiment FIRST (before shouldRenderTarget check)
-        // If this entity has a variant module, render it instead and skip the original
-        // Skip this check if we're already rendering a variant module (to prevent infinite loops)
-        const variantAssignment = skipVariantCheck
-            ? null
-            : this.experiments?.getVariantModuleForTarget(entity.id);
-        if (variantAssignment && variantAssignment.moduleData) {
-            testModeLog('Selwise', `Rendering variant module for ${entityName}: ${entity.id} -> variant: ${variantAssignment.moduleData.id}`);
-            // This entity has a variant module that should be rendered instead
-            await this.renderVariantModule(variantAssignment.moduleData, variantAssignment.experimentId, variantAssignment.variantId, variantAssignment.targetType || type // Use assignment's targetType or current entity type
-            );
-            // Don't render the original entity
-            return false;
-        }
-        // Check if this entity should be rendered (e.g. not replaced by an experiment)
-        if (this.experiments && !this.experiments.shouldRenderTarget(entity.id)) {
-            testModeLog('Selwise', `Skipping ${entityName} (excluded by experiment): ${entity.id}`);
-            return false;
-        }
-        // Check segment targeting
-        if (this.segments && entity.segmentTargetingMode && entity.segmentIds) {
-            const shouldShow = await this.segments.shouldShow(entity.segmentTargetingMode, entity.segmentIds);
-            if (!shouldShow) {
-                testModeLog('Selwise', `Skipping ${entityName} due to segment targeting: ${entity.id}`);
-                return false;
-            }
-        }
-        // Skip if no content
-        if (!entity.contentJson || Object.keys(entity.contentJson).length === 0) {
-            testModeWarn('Selwise', `Skipping empty ${entityName}: ${entity.id}`);
-            return false;
-        }
-        // Check for experiment variant override (config_override mode)
-        let variantContent = normalizeContentFields(entity.contentJson || {});
-        let variantStyles = entity.stylesJson || {};
-        let variantPlacement = entity.placementConfigJson || {};
-        const assignment = this.experiments?.getVariant(entity.id) ||
-            this.experiments?.getAssignmentByTargetId(entity.id);
-        if (assignment) {
-            const config = getEffectiveConfig(assignment);
-            if (config?.content && typeof config.content === 'object') {
-                variantContent = deepMergeExperimentConfig(variantContent, normalizeContentFields(config.content));
-            }
-            if (config?.styles && typeof config.styles === 'object') {
-                variantStyles = deepMergeExperimentConfig(variantStyles, config.styles);
-            }
-            if (config?.placement && typeof config.placement === 'object') {
-                variantPlacement = deepMergeExperimentConfig(variantPlacement, config.placement);
-            }
-        }
-        // Create renderer objects
-        const widgetForRenderer = {
-            id: entity.id,
-            type: entity.type,
-            placementConfigJson: variantPlacement,
-            __entityType: type,
-        };
-        const campaignForRenderer = {
-            id: entity.id,
-            contentJson: variantContent,
-            stylesJson: variantStyles,
-        };
-        // Idempotency guard for SPA re-renders.
-        this.cleanupRenderedEntityById(entity.id, type);
-        const element = this.renderer.render(widgetForRenderer, campaignForRenderer);
-        if (element) {
-            // Mark as rendered to prevent duplicates
-            this.renderedEntities.add(entity.id);
-            // Track impression
-            this.tracker.track('impression', {
-                entityType: type === 'campaign' ? 'campaign' : 'widget',
-                entityId: entity.id,
-            });
-            // Track experiment impression if applicable
-            if (assignment) {
-                this.experiments?.trackImpression(assignment.experimentId);
-            }
-            // Setup click tracking
-            element.addEventListener('click', (e) => {
-                const target = e.target;
-                if (target.tagName === 'A' || target.tagName === 'BUTTON') {
-                    const buttonText = target.textContent?.toLowerCase() || '';
-                    const isAddToCart = /add to cart|buy now|purchase|add to bag|sepete ekle|satın al|buy now/i.test(buttonText);
-                    this.tracker.track('click', {
-                        entityType: type === 'campaign' ? 'campaign' : 'widget',
-                        entityId: entity.id,
-                    });
-                    if (type === 'campaign') {
-                        // Track add_to_cart for campaign buttons that are clearly purchase-related
-                        if (isAddToCart) {
-                            this.tracker.track('add_to_cart', {
-                                entityType: 'campaign',
-                                entityId: entity.id,
-                                metadata: {
-                                    buttonText: target.textContent,
-                                },
-                            });
-                        }
-                    }
-                    // Track experiment conversion
-                    if (assignment) {
-                        this.experiments?.trackConversion(assignment.experimentId);
-                    }
-                }
-            });
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Render a variant module from different_module mode experiment
-     * @param moduleData The module data containing target type and full entity data
-     * @param experimentId The experiment ID
-     * @param variantId The variant ID
-     * @param targetType The target type (widget, campaign, recommendation, etc.)
-     */
-    async renderVariantModule(moduleData, experimentId, variantId, targetType) {
-        // Handle both wrapped and direct moduleData formats
-        // Wrapped: { targetType, data }
-        // Direct: moduleData IS the entity, targetType comes from parameter
-        let data;
-        let effectiveTargetType;
-        if (moduleData.data) {
-            // Wrapped format
-            data = moduleData.data;
-            effectiveTargetType = moduleData.targetType || targetType || 'widget';
-        }
-        else {
-            // Direct format - moduleData IS the entity
-            data = moduleData;
-            effectiveTargetType = targetType || 'widget';
-        }
-        // Track experiment impression
-        if (this.experiments) {
-            this.experiments.trackImpression(experimentId);
-        }
-        // Track impression for the variant
-        this.tracker.track('impression', {
-            entityType: effectiveTargetType,
-            entityId: data.id,
-            metadata: {
-                experimentId,
-                variantId,
-                isVariantModule: true,
-            },
-        });
-        // Render based on target type
-        // Pass skipVariantCheck=true to prevent infinite loops when rendering variant modules
-        switch (effectiveTargetType) {
-            case 'widget':
-                await this.renderEntity(data, 'widget', true);
-                break;
-            case 'campaign':
-                await this.renderEntity(data, 'campaign', true);
-                break;
-            case 'recommendation':
-                // Recommendations are handled by the recommendations module
-                // The module will pick up the variant from the experiment manager
-                testModeLog('Selwise', 'Variant recommendation module will be rendered by recommendations module');
-                break;
-            case 'search_config':
-                // Search is handled by the search module
-                testModeLog('Selwise', 'Variant search config will be applied by search module');
-                break;
-            default:
-                testModeWarn('Selwise', `Unknown target type for variant module: ${effectiveTargetType}`);
-        }
-    }
-    /**
-     * Handle inactive subscription
-     * Disables widget and emits event for parent application to handle
-     *
-     * @param message Error message from server
-     */
-    handleSubscriptionInactive(message) {
-        // Mark widget as disabled
-        this.enabled = false;
-        this.subscriptionInactive = true;
-        this.subscriptionMessage = message;
-        // Emit event for parent to handle
-        if (typeof window !== 'undefined') {
-            const event = new CustomEvent('selwise:subscription-inactive', {
-                detail: { message },
-            });
-            window.dispatchEvent(event);
-        }
-        // Optionally show a subtle console warning for developers
-        testModeWarn('Selwise', 'Subscription inactive. Widget will not display. ' + 'Message: ' + message);
-    }
-}
-export default Selwise;
-//# sourceMappingURL=selwise.js.map