@selwise/widget 0.0.1

package/dist/npm/esm/modules/recommendation/index.js

@@ -0,0 +1,674 @@
+/**
+ * Recommendation Widget Module - Refactored
+ * Handles fetching and rendering of product recommendations
+ */
+import { evaluatePageTargeting, getConflictResolver, getFrequencyCapManager, } from '../../core/index.js';
+import { deepMergeExperimentConfig, getEffectiveConfig } from '../../core/experiment-overrides.js';
+import { debounce } from '../../utils/index.js';
+import { sanitizeCSS } from '../../utils/sanitize.js';
+import { TIMING } from '../../constants.js';
+import { testModeLog, testModeDebug, testModeError, testModeWarn } from '../../utils/logger.js';
+import { resolveRecommendationConfig } from '../contract/recommendation-contract.js';
+// Import utilities
+import { isWidgetInDOM, insertWidget, markRecommendationRoot, removeRecommendationRootsFromDOM, } from './utils/dom.js';
+// Import renderers
+import { createSlider } from './renderers/slider-renderer.js';
+import { createGrid } from './renderers/grid.js';
+import { createList } from './renderers/list.js';
+import { createMasonry } from './renderers/masonry.js';
+// Import product card
+import { createProductCard, executeCardScriptsForRecommendations } from './components/product-card-renderer.js';
+// Import slider controls
+import { initSliderControls } from './slider-controls.js';
+// Import cart handlers
+import { handleAddToCart } from './cart-handlers.js';
+// Import tracking
+import { trackEvent, trackBehavior, getSessionId, trackSliderNavigation, trackSliderSwipe, setupProductImpressionTracking, cleanupTracking, trackWidgetImpression } from './tracking.js';
+// Track rendered widgets to prevent duplicates
+const renderedWidgets = new Set();
+// Track active observers for cleanup
+const activeObservers = new Map();
+// SPA cleanup setup flag
+let spaCleanupSetup = false;
+const frequencyCapManager = getFrequencyCapManager();
+const conflictResolver = getConflictResolver();
+/**
+ * Setup SPA navigation cleanup for recommendation module
+ * Automatically cleans up observers when page navigation is detected
+ */
+function setupSPACleanup() {
+    if (spaCleanupSetup)
+        return;
+    spaCleanupSetup = true;
+    // Listen for navigation events common in SPAs
+    const originalPushState = history.pushState;
+    const originalReplaceState = history.replaceState;
+    history.pushState = (...args) => {
+        originalPushState.apply(history, args);
+        scheduleCleanup();
+    };
+    history.replaceState = (...args) => {
+        originalReplaceState.apply(history, args);
+        scheduleCleanup();
+    };
+    window.addEventListener('popstate', () => scheduleCleanup());
+    window.addEventListener('hashchange', () => scheduleCleanup());
+}
+/**
+ * Schedule deferred cleanup with a small delay
+ */
+function scheduleCleanup() {
+    setTimeout(() => {
+        // Cleanup all observers on navigation
+        activeObservers.forEach((observer, widgetId) => {
+            observer.disconnect();
+        });
+        activeObservers.clear();
+        testModeDebug('Recommendation', 'Cleaned up observers on navigation');
+    }, 500);
+}
+/**
+ * Detect current product ID from various sources
+ * Priority:
+ * 1. Config.currentProductId (explicitly set)
+ * 2. Config.detectCurrentProduct callback
+ * 3. Common meta tags and data attributes
+ * 4. URL patterns (e.g., /product/SKU123)
+ */
+function detectCurrentProductId(config) {
+    // 1. Use explicitly set product ID
+    if (config.currentProductId) {
+        return config.currentProductId;
+    }
+    // 2. Use custom detection function
+    if (config.detectCurrentProduct) {
+        const id = config.detectCurrentProduct();
+        if (id)
+            return id;
+    }
+    // 3. Try common meta tags
+    const metaSelectors = [
+        'meta[property="og:product:id"]',
+        'meta[property="product:id"]',
+        'meta[name="product-id"]',
+        'meta[name="product_id"]',
+        'meta[name="sku"]',
+    ];
+    for (const selector of metaSelectors) {
+        const meta = document.querySelector(selector);
+        if (meta?.content)
+            return meta.content;
+    }
+    // 4. Try common data attributes on product containers
+    const dataSelectors = [
+        '[data-product-id]',
+        '[data-product-sku]',
+        '[data-item-code]',
+        '[data-sku]',
+    ];
+    for (const selector of dataSelectors) {
+        const el = document.querySelector(selector);
+        if (el) {
+            const attr = el.getAttribute('data-product-id')
+                || el.getAttribute('data-product-sku')
+                || el.getAttribute('data-item-code')
+                || el.getAttribute('data-sku');
+            if (attr)
+                return attr;
+        }
+    }
+    // 5. Try JSON-LD structured data
+    const jsonLdScript = document.querySelector('script[type="application/ld+json"]');
+    if (jsonLdScript) {
+        try {
+            const data = JSON.parse(jsonLdScript.textContent || '{}');
+            if (data['@type'] === 'Product' && data.sku)
+                return data.sku;
+            if (data['@type'] === 'Product' && data.productID)
+                return data.productID;
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // 6. No product detected
+    return null;
+}
+function getRecommendationFrequencyCapConfig(widget) {
+    const triggerConfig = widget?.triggerConfig;
+    const frequencyCap = triggerConfig?.frequencyCap;
+    if (!frequencyCap || typeof frequencyCap !== 'object')
+        return undefined;
+    return frequencyCap;
+}
+function selectRecommendationCandidates(widgets) {
+    if (widgets.length <= 1) {
+        return widgets.map((widget) => ({
+            candidateId: `recommendation:${widget.id}`,
+            widget,
+            frequencyKey: `display:recommendation:${widget.id}`,
+            frequencyCapConfig: getRecommendationFrequencyCapConfig(widget),
+        }));
+    }
+    const conflictCandidates = widgets.map((widget) => {
+        const triggerConfig = widget?.triggerConfig || {};
+        const conflictResolution = triggerConfig.conflictResolution || {};
+        const candidate = conflictResolver.applyConfig({
+            id: `recommendation:${widget.id}`,
+            type: 'recommendation',
+            selector: widget.containerSelector,
+            placementPosition: widget.insertPosition,
+            priority: widget.priority ?? conflictResolution.priority,
+            conflictBehavior: conflictResolution.behavior,
+            placementConfig: { conflictResolution },
+        });
+        return {
+            ...candidate,
+            widget,
+            frequencyKey: `display:recommendation:${widget.id}`,
+            frequencyCapConfig: getRecommendationFrequencyCapConfig(widget),
+        };
+    });
+    const resolutionResults = conflictResolver.resolveAll(conflictCandidates);
+    const selectedIds = new Set(resolutionResults.flatMap((result) => result.selected.map((item) => item.id)));
+    return conflictCandidates
+        .filter((candidate) => selectedIds.has(candidate.id))
+        .map((candidate) => ({
+        candidateId: candidate.id,
+        widget: candidate.widget,
+        frequencyKey: candidate.frequencyKey,
+        frequencyCapConfig: candidate.frequencyCapConfig,
+    }));
+}
+export async function initRecommendations(config) {
+    try {
+        // Setup SPA cleanup (only once)
+        setupSPACleanup();
+        const preloadedWidgets = Array.isArray(config.widgets) ? config.widgets : [];
+        let widgets = preloadedWidgets
+            .map((widget) => resolveRecommendationConfig(widget))
+            .filter((widget) => Boolean(widget));
+        // Fall back to API if preloaded widgets are not available
+        if (widgets.length === 0) {
+            const response = await fetch(`${config.apiEndpoint}/public/sites/${config.siteKey}/recommendations?pageUrl=${encodeURIComponent(window.location.href)}`);
+            if (!response.ok)
+                return;
+            const data = await response.json();
+            widgets = Array.isArray(data.widgets)
+                ? data.widgets
+                    .map((widget) => resolveRecommendationConfig(widget))
+                    .filter((widget) => Boolean(widget))
+                : [];
+        }
+        const pageEligibleWidgets = widgets.filter((widget) => {
+            const matchesPage = evaluatePageTargeting(widget.pageTargetingJson, window.location.href);
+            if (!matchesPage) {
+                testModeLog('Recommendation', 'Skipping widget due to page targeting:', widget.id);
+            }
+            return matchesPage;
+        });
+        const candidates = selectRecommendationCandidates(pageEligibleWidgets);
+        // Render each candidate that survives conflict resolution
+        for (const candidate of candidates) {
+            await tryRenderWidget(candidate.widget, config, candidate.frequencyKey, candidate.frequencyCapConfig);
+        }
+    }
+    catch (error) {
+        testModeError('Recommendation', 'Error initializing:', error);
+    }
+}
+// Try to render widget, setup observer if container not ready
+async function tryRenderWidget(widget, config, frequencyKey, frequencyCapConfig) {
+    // Keep in-memory render tracking synchronized with real DOM state.
+    const widgetAlreadyInDom = isWidgetInDOM(widget.id);
+    if (widgetAlreadyInDom && !renderedWidgets.has(widget.id)) {
+        renderedWidgets.add(widget.id);
+        return false;
+    }
+    // If marked as rendered but not in DOM, clear stale state (SPA navigation case).
+    if (!widgetAlreadyInDom && renderedWidgets.has(widget.id)) {
+        renderedWidgets.delete(widget.id);
+    }
+    // Already rendered and in DOM?
+    if (renderedWidgets.has(widget.id))
+        return false;
+    const canShowByFrequencyCap = () => {
+        if (!frequencyCapConfig)
+            return true;
+        const check = frequencyCapManager.canShow(frequencyKey, frequencyCapConfig);
+        if (!check.allowed) {
+            testModeLog('Recommendation', `Skipping widget due to frequency cap (${check.reason || 'limit'})`, widget.id);
+            return false;
+        }
+        return true;
+    };
+    // No container selector? Render to body (fallback)
+    if (!widget.containerSelector) {
+        if (await shouldShowWidget(widget, config)) {
+            if (!canShowByFrequencyCap())
+                return false;
+            // Check for experiment suppression
+            if (config.experimentManager && !config.experimentManager.shouldRenderTarget(widget.id)) {
+                return false;
+            }
+            const widgetToRender = applyExperimentOverrides(widget, config);
+            if (!widgetToRender)
+                return false; // Widget should not be rendered
+            renderedWidgets.add(widgetToRender.id);
+            const rendered = await renderWidget(widgetToRender, config);
+            if (rendered && frequencyCapConfig) {
+                frequencyCapManager.recordShown(frequencyKey);
+            }
+            return rendered;
+        }
+        return false;
+    }
+    // Container exists? Render now
+    const container = document.querySelector(widget.containerSelector);
+    if (container) {
+        if (await shouldShowWidget(widget, config)) {
+            if (!canShowByFrequencyCap())
+                return false;
+            // Check for experiment suppression
+            if (config.experimentManager && !config.experimentManager.shouldRenderTarget(widget.id)) {
+                return false;
+            }
+            const widgetToRender = applyExperimentOverrides(widget, config);
+            if (!widgetToRender)
+                return false; // Widget should not be rendered
+            renderedWidgets.add(widgetToRender.id);
+            const rendered = await renderWidget(widgetToRender, config);
+            if (rendered && frequencyCapConfig) {
+                frequencyCapManager.recordShown(frequencyKey);
+            }
+            return rendered;
+        }
+        return false;
+    }
+    // Container doesn't exist yet - watch for it
+    testModeLog('Recommendation', 'Container not found, setting up observer for:', widget.containerSelector);
+    observeForContainer(widget, config, frequencyKey, frequencyCapConfig);
+    return false;
+}
+// Use MutationObserver to efficiently watch for container appearance
+// Performance optimized: debounced callback, scoped observation, proper cleanup
+function observeForContainer(widget, config, frequencyKey, frequencyCapConfig) {
+    // If already observing this widget, skip
+    if (activeObservers.has(widget.id)) {
+        return;
+    }
+    // Debounced check function to avoid excessive DOM queries
+    const checkForContainer = debounce(async () => {
+        // Re-check: if widget now in DOM, stop
+        if (isWidgetInDOM(widget.id)) {
+            cleanupObserver(widget.id);
+            return;
+        }
+        const container = document.querySelector(widget.containerSelector);
+        if (container && await shouldShowWidget(widget, config)) {
+            if (frequencyCapConfig) {
+                const check = frequencyCapManager.canShow(frequencyKey, frequencyCapConfig);
+                if (!check.allowed) {
+                    cleanupObserver(widget.id);
+                    return;
+                }
+            }
+            // Check for experiment suppression
+            if (config.experimentManager && !config.experimentManager.shouldRenderTarget(widget.id)) {
+                cleanupObserver(widget.id);
+                return;
+            }
+            const widgetToRender = applyExperimentOverrides(widget, config);
+            if (!widgetToRender) {
+                cleanupObserver(widget.id);
+                return; // Widget should not be rendered
+            }
+            renderedWidgets.add(widgetToRender.id);
+            const rendered = await renderWidget(widgetToRender, config);
+            if (rendered && frequencyCapConfig) {
+                frequencyCapManager.recordShown(frequencyKey);
+            }
+            cleanupObserver(widget.id);
+            testModeLog('Recommendation', 'Widget rendered via observer:', widgetToRender.id);
+        }
+    }, TIMING.RESIZE_DEBOUNCE); // 150ms debounce
+    const observer = new MutationObserver((_mutations, _obs) => {
+        checkForContainer();
+    });
+    // Try to scope observation to a parent element if possible
+    // This reduces the number of mutations we need to process
+    const observeTarget = findBestObserveTarget(widget.containerSelector);
+    observer.observe(observeTarget, {
+        childList: true,
+        subtree: true,
+    });
+    // Store observer for cleanup
+    activeObservers.set(widget.id, observer);
+    // Timeout after 10 seconds to prevent memory leaks
+    setTimeout(() => {
+        cleanupObserver(widget.id);
+        checkForContainer.cancel();
+    }, 10000);
+}
+/**
+ * Find the best DOM element to observe for a given selector
+ * Tries to find a parent element that's already in the DOM to reduce observation scope
+ */
+function findBestObserveTarget(selector) {
+    // Try to find a parent element from the selector
+    // e.g., for "#product-page .recommendations" we could observe #product-page
+    const parts = selector.split(/\s+/);
+    for (let i = 0; i < parts.length - 1; i++) {
+        const parentSelector = parts.slice(0, i + 1).join(' ');
+        const parent = document.querySelector(parentSelector);
+        if (parent) {
+            return parent;
+        }
+    }
+    // Fallback to body
+    return document.body;
+}
+/**
+ * Cleanup a specific observer
+ */
+function cleanupObserver(widgetId) {
+    const observer = activeObservers.get(widgetId);
+    if (observer) {
+        observer.disconnect();
+        activeObservers.delete(widgetId);
+    }
+}
+/**
+ * Cleanup all observers and rendered widgets
+ * Call this when navigating away in SPA
+ */
+export function cleanup() {
+    // Disconnect all observers
+    activeObservers.forEach((observer, widgetId) => {
+        observer.disconnect();
+        testModeDebug('Recommendation', 'Cleaned up observer for:', widgetId);
+    });
+    activeObservers.clear();
+    // Remove recommendation DOM roots to prevent duplicate render on SPA re-init.
+    removeRecommendationRootsFromDOM();
+    // Fallback cleanup by known ids in case an old node does not have marker attr.
+    renderedWidgets.forEach((widgetId) => {
+        const existingNode = document.getElementById(`rec-widget-${widgetId}`);
+        if (existingNode) {
+            existingNode.remove();
+        }
+    });
+    // Clear rendered widgets tracking
+    renderedWidgets.clear();
+    // Clear tracking state (e.g. product impression cache)
+    cleanupTracking();
+    testModeDebug('Recommendation', 'Module cleanup complete');
+}
+function applyExperimentOverrides(widget, config) {
+    if (!config.experimentManager)
+        return widget;
+    // Check for different_module mode - variant module replaces this widget
+    const assignment = config.experimentManager.getVariantModuleForTarget(widget.id);
+    if (assignment && assignment.moduleData) {
+        // Unwrap moduleData - could be { targetType, data } or directly the widget
+        const moduleData = assignment.moduleData;
+        const variantWidget = moduleData.data || moduleData;
+        if (variantWidget && variantWidget.id) {
+            testModeLog('Recommendation', 'Rendering variant module instead of original:', variantWidget.id);
+            // Return the variant widget to be rendered instead
+            variantWidget._experimentAssignment = assignment;
+            return variantWidget;
+        }
+    }
+    // Check for config_override mode
+    const configAssignment = config.experimentManager.getVariant(widget.id) ||
+        config.experimentManager.getAssignmentByTargetId(widget.id);
+    if (configAssignment) {
+        const variantConfig = getEffectiveConfig(configAssignment);
+        if (variantConfig) {
+            testModeLog('Recommendation', 'Applying config override:', configAssignment.variantName);
+            const mergedWidget = deepMergeExperimentConfig(widget, variantConfig);
+            Object.assign(widget, mergedWidget);
+            if (variantConfig.content && typeof variantConfig.content === 'object') {
+                const content = variantConfig.content;
+                if (content.title !== undefined) {
+                    widget.title = content.title;
+                    if (widget.titleStyles)
+                        widget.titleStyles.enabled = true;
+                }
+                if (content.subtitle !== undefined) {
+                    widget.subtitle = content.subtitle;
+                    if (widget.subtitleStyles)
+                        widget.subtitleStyles.enabled = true;
+                }
+                else if (content.text !== undefined) {
+                    widget.subtitle = content.text;
+                    if (widget.subtitleStyles)
+                        widget.subtitleStyles.enabled = true;
+                }
+                else if (content.description !== undefined) {
+                    widget.subtitle = content.description;
+                    if (widget.subtitleStyles)
+                        widget.subtitleStyles.enabled = true;
+                }
+            }
+            if (variantConfig.styles && typeof variantConfig.styles === 'object') {
+                widget.containerStyles = deepMergeExperimentConfig((widget.containerStyles || {}), variantConfig.styles);
+            }
+            if (variantConfig.displayType) {
+                widget.displayType = variantConfig.displayType;
+            }
+        }
+        // Mark widget as part of experiment for tracking
+        widget._experimentAssignment = configAssignment;
+    }
+    return widget;
+}
+async function shouldShowWidget(widget, config) {
+    // Check for experiment suppression FIRST (before other checks)
+    // This ensures excluded widgets (different_module mode) are skipped early
+    if (config.experimentManager && !config.experimentManager.shouldRenderTarget(widget.id)) {
+        testModeLog('Recommendation', 'Skipping widget (excluded by experiment):', widget.id);
+        return false;
+    }
+    // If containerSelector is specified, check if element exists
+    if (widget.containerSelector) {
+        const container = document.querySelector(widget.containerSelector);
+        testModeLog('Recommendation', 'Container check:', widget.containerSelector, '-> Found:', !!container);
+        if (!container)
+            return false;
+    }
+    // Page Targeting Logic
+    const targeting = widget.pageTargetingJson;
+    if (!evaluatePageTargeting(targeting, window.location.href)) {
+        return false;
+    }
+    // Segment Targeting Logic
+    if (config.segmentManager && widget.segmentTargetingMode && widget.segmentIds) {
+        const shouldShow = await config.segmentManager.shouldShow(widget.segmentTargetingMode, widget.segmentIds);
+        if (!shouldShow) {
+            testModeLog('Recommendation', 'Skipping widget due to segment targeting:', widget.id);
+            return false;
+        }
+    }
+    return true;
+}
+async function renderWidget(widget, config) {
+    try {
+        // Detect current product ID for product-based strategies (viewed_together, similar_products, etc.)
+        const currentProductId = detectCurrentProductId(config);
+        let sessionId = '';
+        try {
+            sessionId = getSessionId();
+        }
+        catch {
+            sessionId = `sid_fallback_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+        }
+        // Fetch products for this widget
+        const response = await fetch(`${config.apiEndpoint}/public/sites/${config.siteKey}/recommendations/${widget.id}/products`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                currentProductId,
+                pageUrl: window.location.href,
+                sessionId,
+                visitorId: window.selwise_vid,
+                userId: window.selwise_suid,
+            }),
+        });
+        if (!response.ok)
+            return false;
+        const data = await response.json();
+        const products = data.products || [];
+        // Update widget product card definition if provided by API
+        if (data.productCard) {
+            widget.productCard = data.productCard;
+        }
+        if (products.length === 0)
+            return false;
+        // Create widget container
+        const widgetElement = createWidgetElement(widget, products, config);
+        // Insert into page
+        insertWidget(widgetElement, widget);
+        // Track widget impression
+        trackWidgetImpression(widget.id, config).catch(() => {
+            // Non-blocking - don't prevent widget rendering if tracking fails
+        });
+        // Track impression
+        if (widget._experimentAssignment && config.experimentManager) {
+            config.experimentManager.trackImpression(widget._experimentAssignment.experimentId);
+        }
+        // Initialize slider if needed
+        if (widget.displayType === 'slider' || widget.displayType === 'carousel') {
+            initSliderControls(widget, widgetElement, config, trackSliderNavigation, trackSliderSwipe);
+        }
+        // Setup product impression tracking
+        setupProductImpressionTracking(widgetElement, widget.id, config);
+        // Setup click tracking for experiment conversion
+        if (widget._experimentAssignment && config.experimentManager) {
+            widgetElement.addEventListener('click', (e) => {
+                const target = e.target;
+                if (target.closest('.recommendation-card') || target.closest('[data-selwise-action="add-to-cart"]') || target.closest('a') || target.closest('button')) {
+                    const assignment = widget._experimentAssignment;
+                    config.experimentManager?.trackConversion(assignment.experimentId);
+                }
+            });
+        }
+        // Execute custom JS - this runs arbitrary code from widget configuration
+        if (widget.customJS) {
+            try {
+                // Log warning for security auditing
+                testModeWarn('Recommendation', 'Executing custom JS for widget:', widget.id);
+                const customFn = new Function('widgetElement', 'products', 'widgetConfig', widget.customJS);
+                customFn(widgetElement, products, widget);
+            }
+            catch (error) {
+                testModeError('Recommendation', 'Custom JS error:', error);
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        testModeError('Recommendation', 'Error rendering widget:', error);
+        return false;
+    }
+}
+function createWidgetElement(widget, products, config) {
+    const container = document.createElement('div');
+    container.className = 'recommendation-widget';
+    container.id = `rec-widget-${widget.id}`;
+    container.setAttribute('data-widget-id', widget.id);
+    markRecommendationRoot(container);
+    // Apply container styles
+    const cs = widget.containerStyles;
+    container.style.cssText = `
+    background-color: ${cs?.backgroundColor};
+    padding: ${cs?.padding};
+    border-radius: ${cs?.borderRadius}px;
+    max-width: ${cs?.maxWidth};
+    margin: ${cs?.margin};
+    box-sizing: border-box;
+  `;
+    // Create title
+    if (widget.titleStyles?.enabled && widget.title) {
+        const titleEl = document.createElement('h2');
+        titleEl.className = 'recommendation-title';
+        titleEl.textContent = widget.title;
+        const ts = widget.titleStyles;
+        titleEl.style.cssText = `
+      font-size: ${ts.fontSize || 24}px;
+      font-weight: ${ts.fontWeight || 'bold'};
+      color: ${ts.color || '#111111'};
+      text-align: ${ts.textAlign || 'left'};
+      margin-bottom: ${ts.marginBottom || 16}px;
+      margin-top: 0;
+    `;
+        container.appendChild(titleEl);
+    }
+    // Create subtitle
+    if (widget.subtitleStyles?.enabled && widget.subtitle) {
+        const subtitleEl = document.createElement('p');
+        subtitleEl.className = 'recommendation-subtitle';
+        subtitleEl.textContent = widget.subtitle;
+        const ss = widget.subtitleStyles;
+        subtitleEl.style.cssText = `
+      font-size: ${ss.fontSize || 14}px;
+      font-weight: ${ss.fontWeight || 'normal'};
+      color: ${ss.color || '#666666'};
+      text-align: ${ss.textAlign || 'left'};
+      margin-bottom: ${ss.marginBottom || 24}px;
+      margin-top: 0;
+    `;
+        container.appendChild(subtitleEl);
+    }
+    // Create product container based on display type
+    const productContainer = createProductContainer(widget, products, config);
+    container.appendChild(productContainer);
+    // Add custom CSS (sanitized to prevent CSS injection)
+    if (widget.customCSS) {
+        const style = document.createElement('style');
+        style.textContent = sanitizeCSS(widget.customCSS);
+        container.appendChild(style);
+    }
+    // Add custom CSS from Product Card (if custom template)
+    if (widget.productCard && widget.productCard.customCSS) {
+        const cardStyle = document.createElement('style');
+        cardStyle.textContent = sanitizeCSS(widget.productCard.customCSS);
+        container.appendChild(cardStyle);
+    }
+    return container;
+}
+function createProductContainer(widget, products, config) {
+    // Generate unique container ID for card JS execution
+    const containerId = widget.productCard?.customJs
+        ? `recommendation-${widget.id}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
+        : '';
+    // Create product card factory function with bound handlers
+    const productCardFactory = (product) => createProductCard(product, widget, config, handleAddToCart, trackEvent, trackBehavior, containerId);
+    let container;
+    switch (widget.displayType) {
+        case 'slider':
+        case 'carousel':
+            container = createSlider(widget, products, config, productCardFactory);
+            break;
+        case 'grid':
+            container = createGrid(widget, products, config, productCardFactory);
+            break;
+        case 'list':
+            container = createList(widget, products, config, productCardFactory);
+            break;
+        case 'masonry':
+            container = createMasonry(widget, products, config, productCardFactory);
+            break;
+        default:
+            container = createGrid(widget, products, config, productCardFactory);
+    }
+    // Execute custom JavaScript for product cards after DOM insertion
+    if (containerId && widget.productCard?.customJs) {
+        executeCardScriptsForRecommendations(containerId, container);
+    }
+    return container;
+}
+//# sourceMappingURL=index.js.map