@selwise/widget 0.0.1

package/dist/npm/cjs/modules/search/index.js

@@ -0,0 +1,646 @@
+"use strict";
+/**
+ * Search Module for Widget Script
+ * Refactored version - uses modular components
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchModule = void 0;
+const utils_1 = require("../../utils");
+const constants_1 = require("../../constants");
+const logger_1 = require("../../utils/logger");
+const suggestions_1 = require("./components/suggestions");
+const helpers_1 = require("./utils/helpers");
+const sanitize_1 = require("../../utils/sanitize");
+const icons_1 = require("./utils/icons");
+const storage_1 = require("./utils/storage");
+const api_service_1 = require("./services/api-service");
+const tracking_service_1 = require("./services/tracking-service");
+const styles_1 = require("./styles");
+const cart_1 = require("./cart");
+const position_renderers_1 = require("./renderers/position-renderers");
+const results_renderer_1 = require("./renderers/results-renderer");
+const search_item_1 = require("./components/search-item");
+class SearchModule {
+    constructor(apiUrl, siteKey, experimentManager, segmentManager) {
+        this.config = null;
+        this.suggestions = null;
+        this.container = null;
+        this.input = null;
+        this.resultsContainer = null;
+        this.debounceTimer = null;
+        this.cache = new Map();
+        this.cacheMaxAge = 60000;
+        this.isOpen = false;
+        this.focusedIndex = -1;
+        this.selectedCategory = null;
+        this.overlayElement = null;
+        this.searchOpenTime = null;
+        this.lastQuery = '';
+        this.lastResultCount = 0;
+        // Performance: AbortController for canceling pending fetch requests
+        this.abortController = null;
+        // Performance: Bound event handlers for proper cleanup
+        this.boundHandleDocumentClick = null;
+        this.boundHandleDocumentKeydown = null;
+        this.boundHandleHotkey = null;
+        this.boundHandleClearClick = null;
+        this.clearButtonEl = null;
+        this.spaObserver = null;
+        this.isDestroyed = false;
+        // Use shared utility functions
+        this.getOrCreateVisitorId = utils_1.getOrCreateVisitorId;
+        this.getStoredSiteUserId = utils_1.getStoredSiteUserId;
+        this.generateEventId = utils_1.generateEventId;
+        this.apiUrl = apiUrl;
+        this.siteKey = siteKey;
+        this.sessionId = (0, utils_1.getOrCreateSessionId)();
+        this.experimentManager = experimentManager;
+        this.segmentManager = segmentManager;
+    }
+    /**
+     * Destroy the search module and cleanup all resources
+     * Call this when navigating away in SPA or when module is no longer needed
+     */
+    destroy() {
+        if (this.isDestroyed)
+            return;
+        this.isDestroyed = true;
+        // Cancel pending fetch requests
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = null;
+        }
+        // Clear debounce timer
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        // Remove document-level event listeners
+        if (this.boundHandleDocumentClick) {
+            document.removeEventListener('click', this.boundHandleDocumentClick);
+            this.boundHandleDocumentClick = null;
+        }
+        if (this.boundHandleDocumentKeydown) {
+            document.removeEventListener('keydown', this.boundHandleDocumentKeydown);
+            this.boundHandleDocumentKeydown = null;
+        }
+        if (this.boundHandleHotkey) {
+            document.removeEventListener('keydown', this.boundHandleHotkey);
+            this.boundHandleHotkey = null;
+        }
+        if (this.boundHandleClearClick && this.clearButtonEl) {
+            this.clearButtonEl.removeEventListener('click', this.boundHandleClearClick);
+        }
+        this.boundHandleClearClick = null;
+        this.clearButtonEl = null;
+        // Disconnect SPA observer
+        if (this.spaObserver) {
+            this.spaObserver.disconnect();
+            this.spaObserver = null;
+        }
+        // Remove DOM elements
+        if (this.container && this.container.parentNode) {
+            this.container.parentNode.removeChild(this.container);
+        }
+        if (this.overlayElement && this.overlayElement.parentNode) {
+            this.overlayElement.parentNode.removeChild(this.overlayElement);
+        }
+        // Clear cache
+        this.cache.clear();
+        // Null out references to help GC
+        this.container = null;
+        this.input = null;
+        this.resultsContainer = null;
+        this.overlayElement = null;
+        this.config = null;
+        this.suggestions = null;
+        (0, logger_1.testModeDebug)('WidgetSearch', 'Module destroyed and cleaned up');
+    }
+    getAPIConfig() {
+        return { apiUrl: this.apiUrl, siteKey: this.siteKey };
+    }
+    async init() {
+        try {
+            this.config = await (0, api_service_1.loadSearchConfig)(this.getAPIConfig(), this.experimentManager);
+            if (!this.config?.enabled) {
+                (0, logger_1.testModeDebug)('WidgetSearch', 'Search module disabled');
+                return;
+            }
+            // Check test mode
+            if (this.config.isTestMode) {
+                const testModeEnabled = typeof localStorage !== 'undefined' &&
+                    localStorage.getItem(constants_1.STORAGE_KEYS.TEST_MODE) === 'true';
+                if (!testModeEnabled) {
+                    (0, logger_1.testModeDebug)(`WidgetSearch`, `Search is in test mode. Run localStorage.setItem('${constants_1.STORAGE_KEYS.TEST_MODE}', 'true') to view.`);
+                    return;
+                }
+                (0, logger_1.testModeDebug)('WidgetSearch', 'Test mode enabled, showing search widget');
+            }
+            // Check segment targeting
+            if (this.segmentManager && this.config.segmentTargetingMode && this.config.segmentIds) {
+                const shouldShow = await this.segmentManager.shouldShow(this.config.segmentTargetingMode, this.config.segmentIds);
+                if (!shouldShow) {
+                    (0, logger_1.testModeDebug)('WidgetSearch', 'Search module hidden due to segment targeting');
+                    return;
+                }
+            }
+            // Load suggestions data
+            this.suggestions = await (0, api_service_1.loadSearchSuggestions)(this.getAPIConfig());
+            // Inject styles using the new styles module
+            (0, styles_1.injectSearchStyles)(this.config, this.getSuggestionStyles());
+            this.render();
+            this.attachEventListeners();
+            this.setupHotkey();
+            this.setupSpaNavigationWatcher();
+            (0, logger_1.testModeDebug)('WidgetSearch', 'Search module initialized');
+        }
+        catch (error) {
+            (0, logger_1.testModeError)('WidgetSearch', 'Failed to initialize:', error);
+        }
+    }
+    getSuggestionStyles() {
+        return this.suggestions?.styles || {};
+    }
+    setupSpaNavigationWatcher() {
+        (0, logger_1.testModeLog)('WidgetSearch', 'Setting up SPA watcher, position:', this.config?.position);
+        const attachedTriggers = new WeakSet();
+        // Ensure previous observer is cleaned up (re-init / SPA re-render)
+        if (this.spaObserver) {
+            this.spaObserver.disconnect();
+            this.spaObserver = null;
+        }
+        const observer = new MutationObserver(() => {
+            const position = this.config?.position;
+            // INLINE MODE: Re-render search box if container destroyed
+            if (position === 'inline') {
+                if (this.container && !document.body.contains(this.container)) {
+                    this.container = null;
+                    (0, logger_1.testModeLog)('WidgetSearch', 'Inline container was removed');
+                }
+                if (!this.container && this.config?.selector) {
+                    const target = document.querySelector(this.config.selector);
+                    if (target) {
+                        (0, logger_1.testModeLog)('WidgetSearch', 'Re-rendering inline search');
+                        const result = (0, position_renderers_1.renderInlinePosition)(this.config, () => this.attachEventListeners());
+                        if (result) {
+                            this.container = result.container;
+                            this.input = result.input;
+                            this.resultsContainer = result.resultsContainer;
+                            this.attachEventListeners();
+                        }
+                    }
+                }
+            }
+            // MODAL/FLOATING/SIDEBAR: Re-attach triggers if they were recreated
+            if (position === 'modal' || position === 'floating' || position === 'sidebar') {
+                const triggerSelector = this.config?.triggerSelector;
+                if (triggerSelector) {
+                    const triggers = document.querySelectorAll(triggerSelector);
+                    triggers.forEach(trigger => {
+                        if (!attachedTriggers.has(trigger)) {
+                            attachedTriggers.add(trigger);
+                            trigger.addEventListener('click', (e) => {
+                                e.preventDefault();
+                                this.openOverlay();
+                            });
+                            const assignment = this.experimentManager?.getAssignmentByTargetType('search_config');
+                            if (assignment) {
+                                this.experimentManager?.trackEvent('search_instant_open', {
+                                    experimentId: assignment.experimentId,
+                                    variant: assignment.variantId,
+                                    position: this.config?.position,
+                                });
+                            }
+                            (0, logger_1.testModeLog)('WidgetSearch', 'Re-attached trigger listener to:', triggerSelector);
+                            const floatingBtn = document.querySelector('.ws-search-floating-btn:not(.ws-embedded)');
+                            if (floatingBtn) {
+                                floatingBtn.remove();
+                                (0, logger_1.testModeLog)('WidgetSearch', 'Removed fallback floating button');
+                            }
+                        }
+                    });
+                }
+            }
+        });
+        observer.observe(document.body, { childList: true, subtree: true });
+        this.spaObserver = observer;
+        (0, logger_1.testModeLog)('WidgetSearch', 'SPA watcher active for all modes');
+    }
+    render() {
+        if (!this.config)
+            return;
+        const createTriggerFn = (onClick) => {
+            (0, position_renderers_1.createSearchTrigger)(this.config, onClick, icons_1.getSearchIcon);
+        };
+        let result;
+        switch (this.config.position) {
+            case 'inline':
+                result = (0, position_renderers_1.renderInlinePosition)(this.config, () => this.attachEventListeners());
+                break;
+            case 'modal':
+                result = (0, position_renderers_1.renderModalPosition)(this.config, () => this.openOverlay(), () => this.closeOverlay(), createTriggerFn);
+                break;
+            case 'floating':
+                result = (0, position_renderers_1.renderFloatingPosition)(this.config, () => this.openOverlay(), () => this.closeOverlay(), createTriggerFn);
+                break;
+            case 'sidebar':
+                result = (0, position_renderers_1.renderSidebarPosition)(this.config, () => this.openOverlay(), () => this.closeOverlay(), createTriggerFn, icons_1.getCloseIcon);
+                break;
+            case 'fullscreen':
+                result = (0, position_renderers_1.renderFullscreenPosition)(this.config, () => this.openOverlay(), () => this.closeOverlay(), createTriggerFn, icons_1.getCloseIcon);
+                break;
+            default:
+                return;
+        }
+        if (result) {
+            this.container = result.container;
+            this.overlayElement = result.overlayElement || null;
+            this.input = result.input;
+            this.resultsContainer = result.resultsContainer;
+        }
+    }
+    attachEventListeners() {
+        if (!this.input || !this.resultsContainer)
+            return;
+        // Prevent duplicate document listeners if attachEventListeners() is called multiple times
+        if (this.boundHandleDocumentClick) {
+            document.removeEventListener('click', this.boundHandleDocumentClick);
+            this.boundHandleDocumentClick = null;
+        }
+        if (this.boundHandleDocumentKeydown) {
+            document.removeEventListener('keydown', this.boundHandleDocumentKeydown);
+            this.boundHandleDocumentKeydown = null;
+        }
+        // Input listeners (attached to specific elements, auto-cleaned with DOM removal)
+        this.input.addEventListener('input', (e) => this.handleInput(e));
+        this.input.addEventListener('focus', () => this.handleFocus());
+        this.input.addEventListener('keydown', (e) => this.handleKeydown(e));
+        if (this.boundHandleClearClick && this.clearButtonEl) {
+            this.clearButtonEl.removeEventListener('click', this.boundHandleClearClick);
+        }
+        this.boundHandleClearClick = null;
+        this.clearButtonEl = this.container?.querySelector('.ws-search-clear') || null;
+        if (this.clearButtonEl) {
+            this.boundHandleClearClick = (_e) => this.clearSearch();
+            this.clearButtonEl.addEventListener('click', this.boundHandleClearClick);
+        }
+        // Document-level listeners - store bound references for cleanup
+        this.boundHandleDocumentClick = (e) => {
+            if (!this.container?.contains(e.target) && !this.overlayElement?.contains(e.target)) {
+                this.closeResults();
+            }
+        };
+        document.addEventListener('click', this.boundHandleDocumentClick);
+        this.boundHandleDocumentKeydown = (e) => {
+            if (e.key === 'Escape') {
+                this.closeResults();
+                this.closeOverlay();
+            }
+        };
+        document.addEventListener('keydown', this.boundHandleDocumentKeydown);
+    }
+    setupHotkey() {
+        if (!this.config?.hotkey)
+            return;
+        // Store bound reference for cleanup
+        this.boundHandleHotkey = (e) => {
+            const hotkey = this.config.hotkey.toLowerCase();
+            const isCtrl = hotkey.includes('ctrl') && (e.ctrlKey || e.metaKey);
+            const key = hotkey.replace('ctrl+', '').replace('cmd+', '');
+            if (isCtrl && e.key.toLowerCase() === key) {
+                e.preventDefault();
+                this.openOverlay();
+                setTimeout(() => this.input?.focus(), 100);
+            }
+        };
+        document.addEventListener('keydown', this.boundHandleHotkey);
+    }
+    handleInput(e) {
+        const query = e.target.value.trim();
+        this.container?.classList.toggle('has-value', query.length > 0);
+        if (query.length < (this.config?.minChars || 2)) {
+            if (query.length === 0) {
+                this.renderSuggestions();
+            }
+            else {
+                this.closeResults();
+            }
+            return;
+        }
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => this.search(query), this.config?.debounceMs || 300);
+    }
+    handleFocus() {
+        const query = this.input?.value?.trim() || '';
+        if (query.length < (this.config?.minChars || 2)) {
+            this.renderSuggestions();
+            return;
+        }
+        if (this.config?.searchOnFocus && query) {
+            this.search(query);
+        }
+    }
+    handleKeydown(e) {
+        if (!this.isOpen)
+            return;
+        const items = this.resultsContainer?.querySelectorAll('.ws-search-item');
+        if (!items?.length)
+            return;
+        switch (e.key) {
+            case 'ArrowDown':
+                e.preventDefault();
+                this.focusedIndex = this.focusedIndex < items.length - 1 ? this.focusedIndex + 1 : 0;
+                break;
+            case 'ArrowUp':
+                e.preventDefault();
+                this.focusedIndex = this.focusedIndex > 0 ? this.focusedIndex - 1 : items.length - 1;
+                break;
+            case 'Enter':
+                e.preventDefault();
+                if (this.focusedIndex >= 0)
+                    items[this.focusedIndex].click();
+                return;
+            default:
+                return;
+        }
+        items.forEach((item, i) => item.classList.toggle('focused', i === this.focusedIndex));
+        items[this.focusedIndex]?.scrollIntoView({ block: 'nearest' });
+    }
+    async search(query) {
+        const isRealSearch = query !== '*' && query.length >= (this.config?.minChars || 2);
+        const cacheKey = `${query}|${this.selectedCategory || ''}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < this.cacheMaxAge) {
+            this.renderResults(cached.data);
+            this.lastQuery = query;
+            this.lastResultCount = cached.data.total;
+            return;
+        }
+        // Cancel any pending search request
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+        this.abortController = new AbortController();
+        this.showLoading();
+        try {
+            const data = await (0, api_service_1.performSearch)(this.getAPIConfig(), query, {
+                maxResults: this.config?.maxResults || 10,
+                category: this.selectedCategory,
+                signal: this.abortController.signal
+            });
+            // Handle redirect if present
+            if (data.redirect) {
+                (0, logger_1.testModeDebug)('WidgetSearch', 'Redirecting to:', data.redirect);
+                // Close search UI before redirecting
+                this.closeResults();
+                this.closeOverlay();
+                // Navigate to redirect URL
+                window.location.href = data.redirect;
+                return;
+            }
+            this.cache.set(cacheKey, { data, timestamp: Date.now() });
+            this.renderResults(data);
+            this.lastQuery = query;
+            this.lastResultCount = data.total;
+            if (isRealSearch) {
+                (0, storage_1.addRecentSearch)(query, this.suggestions?.recentSearches?.maxCount || 5, this.siteKey);
+                (0, api_service_1.logSearchQuery)(this.getAPIConfig(), query, data.total, this.sessionId, this.getOrCreateVisitorId(), this.getStoredSiteUserId(), this.generateEventId());
+                if (data.total === 0 && !data.redirect) {
+                    (0, tracking_service_1.trackZeroResults)(this.getAPIConfig(), query, this.sessionId, this.getOrCreateVisitorId(), this.getStoredSiteUserId(), this.generateEventId());
+                }
+            }
+        }
+        catch (error) {
+            // Silently ignore aborted requests (user typed faster than API responded)
+            if (error instanceof Error && error.name === 'AbortError') {
+                return;
+            }
+            (0, logger_1.testModeError)('WidgetSearch', 'Search failed:', error);
+            this.showEmpty('Search temporarily unavailable');
+        }
+    }
+    renderResults(data) {
+        if (!this.resultsContainer || !this.config)
+            return;
+        if (data.hits.length === 0) {
+            this.showEmpty(this.config.styles?.textEmpty || 'No products found');
+            return;
+        }
+        // Generate unique container ID for card JS execution
+        const containerId = `search-results-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        const html = (0, results_renderer_1.renderResultsHTML)(data, {
+            config: this.config,
+            selectedCategory: this.selectedCategory,
+            formatPrice: (price) => (0, helpers_1.formatPrice)(price, this.config?.styles),
+            formatCategoryName: (name) => this.formatCategoryName(name)
+        }, containerId);
+        this.resultsContainer.innerHTML = (0, sanitize_1.sanitizeHTML)(html);
+        // Execute custom JavaScript for product cards after DOM insertion
+        if (this.config.productCard?.customJs) {
+            (0, search_item_1.executeCardScriptsForSearch)(containerId, this.resultsContainer);
+        }
+        // Attach category listeners
+        (0, results_renderer_1.attachCategoryListeners)(this.resultsContainer, (category) => {
+            this.selectedCategory = category;
+            if (this.input?.value)
+                this.search(this.input.value);
+        });
+        // Attach item click listeners
+        this.resultsContainer.querySelectorAll('.ws-search-item').forEach(item => {
+            item.addEventListener('click', (e) => {
+                const target = e.target;
+                const productItemCode = item.dataset.productId;
+                const hit = data.hits.find((h) => (h.itemCode || h.id) === productItemCode);
+                const addToCartAction = target.closest('[data-selwise-action="add-to-cart"]');
+                if (addToCartAction) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    if (hit)
+                        this.handleAddToCartClick(hit);
+                    return;
+                }
+                if (productItemCode) {
+                    (0, tracking_service_1.trackClick)(this.getAPIConfig(), productItemCode, this.sessionId, this.getOrCreateVisitorId(), this.getStoredSiteUserId(), this.generateEventId(), this.selectedCategory || undefined, this.lastQuery);
+                }
+                if (!this.config?.keepOpen) {
+                    this.closeResults();
+                    this.closeOverlay();
+                }
+                const link = item.querySelector('a')?.href || hit?.url;
+                if (link && !addToCartAction) {
+                    window.location.href = link;
+                }
+            });
+        });
+        this.focusedIndex = 0;
+        this.openResults();
+    }
+    handleAddToCartClick(hit) {
+        const context = {
+            config: this.getAPIConfig(),
+            sessionId: this.sessionId,
+            getVisitorId: () => this.getOrCreateVisitorId(),
+            getSiteUserId: () => this.getStoredSiteUserId(),
+            generateEventId: () => this.generateEventId(),
+            getResultsContainer: () => this.resultsContainer,
+            cartPlatform: (this.config?.cartPlatform || 'custom'),
+            customCartScript: this.config?.customCartScript
+        };
+        (0, cart_1.handleAddToCart)(hit, context);
+    }
+    renderSuggestions() {
+        if (!this.resultsContainer || !this.config || !this.suggestions)
+            return;
+        const html = (0, suggestions_1.renderSuggestions)(this.suggestions, this.config, (0, storage_1.getRecentSearches)(5, this.siteKey), {
+            formatPrice: (price) => (0, helpers_1.formatPrice)(price, this.config?.styles),
+            escapeHtml: helpers_1.escapeHtml,
+            formatCategoryName: helpers_1.formatCategoryName
+        });
+        if (!html)
+            return;
+        this.resultsContainer.innerHTML = (0, sanitize_1.sanitizeHTML)(html);
+        this.attachSuggestionListeners();
+        this.openResults();
+    }
+    attachSuggestionListeners() {
+        if (!this.resultsContainer)
+            return;
+        this.resultsContainer.querySelector('.ws-clear-recent')?.addEventListener('click', (e) => {
+            e.stopPropagation();
+            (0, storage_1.clearRecentSearches)(this.siteKey);
+            this.renderSuggestions();
+        });
+        this.resultsContainer.querySelectorAll('.ws-remove-recent').forEach(btn => {
+            btn.addEventListener('click', (e) => {
+                e.stopPropagation();
+                const term = btn.dataset.term;
+                if (term) {
+                    (0, storage_1.removeRecentSearch)(term, this.siteKey);
+                    this.renderSuggestions();
+                }
+            });
+        });
+        this.resultsContainer.querySelectorAll('.ws-recent-item').forEach(item => {
+            item.addEventListener('click', () => {
+                const term = item.dataset.term;
+                if (term && this.input) {
+                    (0, tracking_service_1.trackRecentSearchClick)(this.getAPIConfig(), term, this.sessionId, this.getOrCreateVisitorId(), this.getStoredSiteUserId(), this.generateEventId());
+                    this.input.value = term;
+                    this.container?.classList.add('has-value');
+                    this.search(term);
+                }
+            });
+        });
+        this.resultsContainer.querySelectorAll('.ws-popular-search-item').forEach(item => {
+            item.addEventListener('click', () => {
+                const term = item.dataset.term;
+                if (term && this.input) {
+                    (0, tracking_service_1.trackPopularSearchClick)(this.getAPIConfig(), term, this.sessionId, this.getOrCreateVisitorId(), this.getStoredSiteUserId(), this.generateEventId());
+                    this.input.value = term;
+                    this.container?.classList.add('has-value');
+                    this.search(term);
+                }
+            });
+        });
+        this.resultsContainer.querySelectorAll('.ws-category-card').forEach(card => {
+            card.addEventListener('click', (e) => {
+                e.preventDefault();
+                const category = card.dataset.category;
+                if (category && this.input) {
+                    (0, tracking_service_1.trackPopularCategoryClick)(this.getAPIConfig(), category, this.sessionId, this.getOrCreateVisitorId(), this.getStoredSiteUserId(), this.generateEventId());
+                    this.selectedCategory = category;
+                    this.input.value = '';
+                    this.search('*');
+                }
+            });
+        });
+        this.resultsContainer.querySelectorAll('.ws-product-card').forEach(card => {
+            card.addEventListener('click', () => {
+                const productItemCode = card.dataset.productId;
+                if (productItemCode) {
+                    (0, tracking_service_1.trackPopularProductClick)(this.getAPIConfig(), productItemCode, this.sessionId, this.getOrCreateVisitorId(), this.getStoredSiteUserId(), this.generateEventId());
+                    (0, tracking_service_1.trackClick)(this.getAPIConfig(), productItemCode, this.sessionId, this.getOrCreateVisitorId(), this.getStoredSiteUserId(), this.generateEventId());
+                }
+            });
+        });
+    }
+    showLoading() {
+        if (!this.resultsContainer)
+            return;
+        const loadingText = (0, helpers_1.escapeHtml)(this.config?.styles?.textLoading || 'Searching...');
+        this.resultsContainer.innerHTML = (0, sanitize_1.sanitizeHTML)(`
+      <div class="ws-search-loading">
+        <div class="ws-search-spinner"></div>
+        <span>${loadingText}</span>
+      </div>
+    `);
+        this.openResults();
+    }
+    showEmpty(message) {
+        if (!this.resultsContainer)
+            return;
+        const safeMessage = (0, helpers_1.escapeHtml)(message);
+        this.resultsContainer.innerHTML = (0, sanitize_1.sanitizeHTML)(`
+      <div class="ws-search-empty">
+        ${(0, icons_1.getSearchIcon)('', 48)}
+        <p style="margin-top:12px;">${safeMessage}</p>
+      </div>
+    `);
+        this.openResults();
+    }
+    openResults() {
+        this.resultsContainer?.classList.add('open');
+        if (this.config?.position === 'inline' && this.config?.animationType && this.config.animationType !== 'none') {
+            this.resultsContainer?.classList.add(`anim-${this.config.animationType}`);
+        }
+        this.isOpen = true;
+    }
+    closeResults() {
+        this.resultsContainer?.classList.remove('open');
+        this.isOpen = false;
+        this.focusedIndex = -1;
+    }
+    openOverlay() {
+        this.overlayElement?.classList.add('open');
+        if (this.config?.animationType && this.config.animationType !== 'none') {
+            this.overlayElement?.classList.add(`anim-${this.config.animationType}`);
+        }
+        this.searchOpenTime = Date.now();
+        (0, tracking_service_1.trackSearchOpen)(this.getAPIConfig(), 'click', this.sessionId, this.getOrCreateVisitorId(), this.getStoredSiteUserId(), this.generateEventId());
+        setTimeout(() => this.input?.focus(), 100);
+    }
+    closeOverlay() {
+        this.overlayElement?.classList.remove('open');
+        if (this.searchOpenTime) {
+            const dwellTime = Date.now() - this.searchOpenTime;
+            (0, tracking_service_1.trackSearchClose)(this.getAPIConfig(), this.lastQuery, this.lastResultCount, dwellTime, this.sessionId, this.getOrCreateVisitorId(), this.getStoredSiteUserId(), this.generateEventId());
+            this.searchOpenTime = null;
+        }
+        this.closeResults();
+        this.clearSearch();
+    }
+    clearSearch() {
+        if (this.input)
+            this.input.value = '';
+        this.container?.classList.remove('has-value');
+        this.closeResults();
+        this.selectedCategory = null;
+    }
+    formatCategoryName(name) {
+        const s = this.config?.styles || {};
+        const mode = s.categoryNaming || 'full_path';
+        if (!name)
+            return '';
+        if (mode === 'last_part') {
+            const parts = name.split('>');
+            return parts[parts.length - 1].trim();
+        }
+        if (mode === 'first_part') {
+            return name.split('>')[0].trim();
+        }
+        return name;
+    }
+}
+exports.SearchModule = SearchModule;
+//# sourceMappingURL=index.js.map