@seekora-ai/ui-sdk-core 1.0.0

package/dist/index.js

@@ -0,0 +1,1994 @@
+'use strict';
+
+/**
+ * Field Mapping Utilities
+ *
+ * Shared utilities for extracting and mapping fields from API responses
+ */
+/**
+ * Get nested value from object using dot notation path
+ */
+const getNestedValue$1 = (obj, path) => {
+    if (!path)
+        return undefined;
+    return path.split('.').reduce((current, key) => current?.[key], obj);
+};
+/**
+ * Format price value with currency
+ */
+const formatPrice = (value, currency = '₹') => {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === 'number')
+        return `${currency}${value}`;
+    if (typeof value === 'string') {
+        const num = parseFloat(value);
+        if (!isNaN(num))
+            return `${currency}${num}`;
+        return value;
+    }
+    return String(value);
+};
+/**
+ * Extract field value using dot notation path
+ */
+const extractField = (item, path) => {
+    if (!path)
+        return undefined;
+    return getNestedValue$1(item, path);
+};
+
+/**
+ * Theme Management Utilities
+ *
+ * Shared theme utilities for creating and merging themes
+ */
+/**
+ * Create a complete theme from a partial theme configuration
+ */
+const createTheme = (config, baseTheme) => {
+    return {
+        colors: {
+            ...baseTheme.colors,
+            ...config.colors,
+        },
+        typography: {
+            ...baseTheme.typography,
+            ...config.typography,
+            fontSize: {
+                ...baseTheme.typography.fontSize,
+                ...config.typography?.fontSize,
+            },
+        },
+        spacing: {
+            ...baseTheme.spacing,
+            ...config.spacing,
+        },
+        borderRadius: (config.borderRadius ?? baseTheme.borderRadius),
+        shadows: {
+            ...baseTheme.shadows,
+            ...config.shadows,
+        },
+        transitions: {
+            ...baseTheme.transitions,
+            ...config.transitions,
+        },
+        breakpoints: {
+            ...baseTheme.breakpoints,
+            ...config.breakpoints,
+        },
+        zIndex: {
+            ...baseTheme.zIndex,
+            ...config.zIndex,
+        },
+    };
+};
+/**
+ * Merge multiple themes together
+ */
+const mergeThemes = (baseTheme, ...themes) => {
+    return themes.reduce((acc, theme) => {
+        return {
+            colors: { ...acc.colors, ...theme.colors },
+            typography: {
+                ...acc.typography,
+                ...theme.typography,
+                fontSize: {
+                    ...acc.typography?.fontSize,
+                    ...theme.typography?.fontSize,
+                },
+            },
+            spacing: { ...acc.spacing, ...theme.spacing },
+            borderRadius: (theme.borderRadius ?? acc.borderRadius),
+            shadows: { ...acc.shadows, ...theme.shadows },
+            transitions: { ...acc.transitions, ...theme.transitions },
+            breakpoints: { ...acc.breakpoints, ...theme.breakpoints },
+            zIndex: { ...acc.zIndex, ...theme.zIndex },
+        };
+    }, baseTheme);
+};
+
+/**
+ * CSS Variables Theme System
+ *
+ * Generates CSS variables from theme configuration
+ * Provides utilities for injecting and managing CSS themes
+ */
+/**
+ * Convert a theme object to CSS variables
+ */
+function themeToCSSVariables(theme, config = {}) {
+    const { scope = ':root', prefix = '--seekora' } = config;
+    const variables = [];
+    // Colors
+    Object.entries(theme.colors).forEach(([key, value]) => {
+        variables.push(`${prefix}-color-${key}: ${value};`);
+    });
+    // Typography
+    variables.push(`${prefix}-font-family: ${theme.typography.fontFamily};`);
+    Object.entries(theme.typography.fontSize).forEach(([key, value]) => {
+        variables.push(`${prefix}-font-size-${key}: ${value};`);
+    });
+    if (theme.typography.fontWeight) {
+        Object.entries(theme.typography.fontWeight).forEach(([key, value]) => {
+            variables.push(`${prefix}-font-weight-${key}: ${value};`);
+        });
+    }
+    if (theme.typography.lineHeight) {
+        Object.entries(theme.typography.lineHeight).forEach(([key, value]) => {
+            variables.push(`${prefix}-line-height-${key}: ${value};`);
+        });
+    }
+    // Spacing
+    Object.entries(theme.spacing).forEach(([key, value]) => {
+        variables.push(`${prefix}-spacing-${key}: ${value};`);
+    });
+    // Border Radius
+    if (typeof theme.borderRadius === 'string') {
+        variables.push(`${prefix}-border-radius: ${theme.borderRadius};`);
+    }
+    else {
+        Object.entries(theme.borderRadius).forEach(([key, value]) => {
+            variables.push(`${prefix}-border-radius-${key}: ${value};`);
+        });
+    }
+    // Shadows
+    if (theme.shadows) {
+        Object.entries(theme.shadows).forEach(([key, value]) => {
+            variables.push(`${prefix}-shadow-${key}: ${value};`);
+        });
+    }
+    // Transitions
+    if (theme.transitions) {
+        Object.entries(theme.transitions).forEach(([key, value]) => {
+            variables.push(`${prefix}-transition-${key}: ${value};`);
+        });
+    }
+    // Z-Index
+    if (theme.zIndex) {
+        Object.entries(theme.zIndex).forEach(([key, value]) => {
+            variables.push(`${prefix}-z-index-${key}: ${value};`);
+        });
+    }
+    return `${scope} {\n  ${variables.join('\n  ')}\n}`;
+}
+/**
+ * Generate complete CSS stylesheet with variables and optional component classes
+ */
+function generateThemeStylesheet(theme, config = {}) {
+    const { prefix = '--seekora', includeClasses = true } = config;
+    const sections = [];
+    // CSS Variables
+    sections.push(themeToCSSVariables(theme, config));
+    // Component classes (BEM naming convention)
+    if (includeClasses) {
+        sections.push(generateComponentClasses(prefix));
+    }
+    return sections.join('\n\n');
+}
+/**
+ * Generate BEM-style component classes
+ */
+function generateComponentClasses(prefix) {
+    return `
+/* Seekora UI SDK Component Classes */
+
+/* Search Bar */
+.seekora-search-bar {
+  position: relative;
+  display: flex;
+  align-items: center;
+  background-color: var(${prefix}-color-background);
+  border: 1px solid var(${prefix}-color-border);
+  border-radius: var(${prefix}-border-radius-medium, var(${prefix}-border-radius));
+  transition: var(${prefix}-transition-fast);
+}
+
+.seekora-search-bar--focused {
+  border-color: var(${prefix}-color-primary);
+  box-shadow: 0 0 0 2px var(${prefix}-color-focus);
+}
+
+.seekora-search-bar__input {
+  flex: 1;
+  padding: var(${prefix}-spacing-medium);
+  font-size: var(${prefix}-font-size-medium);
+  font-family: var(${prefix}-font-family);
+  color: var(${prefix}-color-text);
+  background: transparent;
+  border: none;
+  outline: none;
+}
+
+.seekora-search-bar__input::placeholder {
+  color: var(${prefix}-color-textSecondary);
+}
+
+.seekora-search-bar__button {
+  padding: var(${prefix}-spacing-small) var(${prefix}-spacing-medium);
+  font-size: var(${prefix}-font-size-medium);
+  color: #ffffff;
+  background-color: var(${prefix}-color-primary);
+  border: none;
+  border-radius: var(${prefix}-border-radius-medium, var(${prefix}-border-radius));
+  cursor: pointer;
+  transition: var(${prefix}-transition-fast);
+}
+
+.seekora-search-bar__button:hover {
+  background-color: var(${prefix}-color-hover);
+}
+
+/* Search Results */
+.seekora-results {
+  background-color: var(${prefix}-color-background);
+}
+
+.seekora-results__list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+.seekora-results__item {
+  display: flex;
+  gap: var(${prefix}-spacing-medium);
+  padding: var(${prefix}-spacing-medium);
+  border-bottom: 1px solid var(${prefix}-color-border);
+  cursor: pointer;
+  transition: var(${prefix}-transition-fast);
+}
+
+.seekora-results__item:hover {
+  background-color: var(${prefix}-color-hover);
+}
+
+.seekora-results__item--active {
+  background-color: var(${prefix}-color-hover);
+}
+
+.seekora-results__image {
+  width: 80px;
+  height: 80px;
+  object-fit: cover;
+  border-radius: var(${prefix}-border-radius-small, var(${prefix}-border-radius));
+}
+
+.seekora-results__content {
+  flex: 1;
+}
+
+.seekora-results__title {
+  margin: 0 0 var(${prefix}-spacing-small) 0;
+  font-size: var(${prefix}-font-size-medium);
+  font-weight: var(${prefix}-font-weight-semibold, 600);
+  color: var(${prefix}-color-text);
+}
+
+.seekora-results__description {
+  margin: 0;
+  font-size: var(${prefix}-font-size-small);
+  color: var(${prefix}-color-textSecondary);
+  line-height: var(${prefix}-line-height-normal, 1.5);
+}
+
+.seekora-results__price {
+  margin-top: var(${prefix}-spacing-small);
+  font-size: var(${prefix}-font-size-medium);
+  font-weight: var(${prefix}-font-weight-bold, 700);
+  color: var(${prefix}-color-primary);
+}
+
+.seekora-results__empty {
+  padding: var(${prefix}-spacing-large);
+  text-align: center;
+  color: var(${prefix}-color-textSecondary);
+}
+
+.seekora-results__loading {
+  padding: var(${prefix}-spacing-large);
+  text-align: center;
+  color: var(${prefix}-color-textSecondary);
+}
+
+/* Pagination */
+.seekora-pagination {
+  display: flex;
+  justify-content: center;
+  gap: var(${prefix}-spacing-small);
+  padding: var(${prefix}-spacing-medium) 0;
+}
+
+.seekora-pagination__item {
+  min-width: 36px;
+  height: 36px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0 var(${prefix}-spacing-small);
+  font-size: var(${prefix}-font-size-medium);
+  color: var(${prefix}-color-text);
+  background-color: var(${prefix}-color-background);
+  border: 1px solid var(${prefix}-color-border);
+  border-radius: var(${prefix}-border-radius-small, var(${prefix}-border-radius));
+  cursor: pointer;
+  transition: var(${prefix}-transition-fast);
+}
+
+.seekora-pagination__item:hover:not(.seekora-pagination__item--disabled) {
+  background-color: var(${prefix}-color-hover);
+  border-color: var(${prefix}-color-primary);
+}
+
+.seekora-pagination__item--active {
+  background-color: var(${prefix}-color-primary);
+  border-color: var(${prefix}-color-primary);
+  color: #ffffff;
+}
+
+.seekora-pagination__item--disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+/* Facets */
+.seekora-facets {
+  font-family: var(${prefix}-font-family);
+}
+
+.seekora-facets__facet {
+  margin-bottom: var(${prefix}-spacing-large);
+}
+
+.seekora-facets__title {
+  margin: 0 0 var(${prefix}-spacing-small) 0;
+  font-size: var(${prefix}-font-size-medium);
+  font-weight: var(${prefix}-font-weight-semibold, 600);
+  color: var(${prefix}-color-text);
+}
+
+.seekora-facets__list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+.seekora-facets__item {
+  display: flex;
+  align-items: center;
+  gap: var(${prefix}-spacing-small);
+  padding: var(${prefix}-spacing-small) 0;
+  cursor: pointer;
+}
+
+.seekora-facets__checkbox {
+  width: 18px;
+  height: 18px;
+  accent-color: var(${prefix}-color-primary);
+}
+
+.seekora-facets__label {
+  flex: 1;
+  font-size: var(${prefix}-font-size-small);
+  color: var(${prefix}-color-text);
+}
+
+.seekora-facets__count {
+  font-size: var(${prefix}-font-size-small);
+  color: var(${prefix}-color-textSecondary);
+}
+
+.seekora-facets__show-more {
+  margin-top: var(${prefix}-spacing-small);
+  font-size: var(${prefix}-font-size-small);
+  color: var(${prefix}-color-primary);
+  background: none;
+  border: none;
+  cursor: pointer;
+  text-decoration: underline;
+}
+
+/* Stats */
+.seekora-stats {
+  font-size: var(${prefix}-font-size-small);
+  color: var(${prefix}-color-textSecondary);
+}
+
+.seekora-stats__count {
+  font-weight: var(${prefix}-font-weight-semibold, 600);
+  color: var(${prefix}-color-text);
+}
+
+/* Sort By */
+.seekora-sort-by {
+  display: flex;
+  align-items: center;
+  gap: var(${prefix}-spacing-small);
+}
+
+.seekora-sort-by__label {
+  font-size: var(${prefix}-font-size-medium);
+  color: var(${prefix}-color-text);
+}
+
+.seekora-sort-by__select {
+  padding: var(${prefix}-spacing-small) var(${prefix}-spacing-medium);
+  font-size: var(${prefix}-font-size-medium);
+  color: var(${prefix}-color-text);
+  background-color: var(${prefix}-color-background);
+  border: 1px solid var(${prefix}-color-border);
+  border-radius: var(${prefix}-border-radius-medium, var(${prefix}-border-radius));
+  cursor: pointer;
+  outline: none;
+}
+
+/* Current Refinements */
+.seekora-refinements {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(${prefix}-spacing-small);
+}
+
+.seekora-refinements__item {
+  display: inline-flex;
+  align-items: center;
+  gap: var(${prefix}-spacing-small);
+  padding: var(${prefix}-spacing-small) var(${prefix}-spacing-medium);
+  font-size: var(${prefix}-font-size-small);
+  background-color: var(${prefix}-color-hover);
+  border: 1px solid var(${prefix}-color-border);
+  border-radius: var(${prefix}-border-radius-full, 9999px);
+}
+
+.seekora-refinements__label {
+  font-weight: var(${prefix}-font-weight-medium, 500);
+  color: var(${prefix}-color-text);
+}
+
+.seekora-refinements__value {
+  color: var(${prefix}-color-text);
+}
+
+.seekora-refinements__clear {
+  width: 16px;
+  height: 16px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  font-size: 14px;
+  color: var(${prefix}-color-textSecondary);
+  background: none;
+  border: none;
+  border-radius: 50%;
+  cursor: pointer;
+  transition: var(${prefix}-transition-fast);
+}
+
+.seekora-refinements__clear:hover {
+  color: var(${prefix}-color-text);
+  background-color: var(${prefix}-color-border);
+}
+
+.seekora-refinements__clear-all {
+  padding: var(${prefix}-spacing-small) var(${prefix}-spacing-medium);
+  font-size: var(${prefix}-font-size-small);
+  color: var(${prefix}-color-primary);
+  background: none;
+  border: none;
+  cursor: pointer;
+  text-decoration: underline;
+}
+
+/* Range Input */
+.seekora-range-input {
+  font-family: var(${prefix}-font-family);
+}
+
+.seekora-range-input__label {
+  display: block;
+  margin-bottom: var(${prefix}-spacing-small);
+  font-size: var(${prefix}-font-size-medium);
+  font-weight: var(${prefix}-font-weight-medium, 500);
+  color: var(${prefix}-color-text);
+}
+
+.seekora-range-input__group {
+  display: flex;
+  align-items: center;
+  gap: var(${prefix}-spacing-small);
+}
+
+.seekora-range-input__input {
+  flex: 1;
+  padding: var(${prefix}-spacing-small);
+  font-size: var(${prefix}-font-size-medium);
+  color: var(${prefix}-color-text);
+  background-color: var(${prefix}-color-background);
+  border: 1px solid var(${prefix}-color-border);
+  border-radius: var(${prefix}-border-radius-medium, var(${prefix}-border-radius));
+  outline: none;
+}
+
+.seekora-range-input__separator {
+  color: var(${prefix}-color-textSecondary);
+}
+
+.seekora-range-input__button {
+  padding: var(${prefix}-spacing-small) var(${prefix}-spacing-medium);
+  font-size: var(${prefix}-font-size-medium);
+  color: #ffffff;
+  background-color: var(${prefix}-color-primary);
+  border: none;
+  border-radius: var(${prefix}-border-radius-medium, var(${prefix}-border-radius));
+  cursor: pointer;
+}
+
+/* Highlight */
+.seekora-highlight mark,
+.seekora-highlight__highlighted {
+  background-color: var(${prefix}-color-warning, #fff59d);
+  font-weight: var(${prefix}-font-weight-semibold, 600);
+  padding: 0 2px;
+  border-radius: 2px;
+}
+
+/* Infinite Hits */
+.seekora-infinite-hits__show-more {
+  display: block;
+  width: 100%;
+  padding: var(${prefix}-spacing-medium);
+  margin-top: var(${prefix}-spacing-medium);
+  font-size: var(${prefix}-font-size-medium);
+  font-weight: var(${prefix}-font-weight-medium, 500);
+  color: #ffffff;
+  background-color: var(${prefix}-color-primary);
+  border: none;
+  border-radius: var(${prefix}-border-radius-medium, var(${prefix}-border-radius));
+  cursor: pointer;
+  transition: var(${prefix}-transition-fast);
+}
+
+.seekora-infinite-hits__show-more:disabled {
+  background-color: var(${prefix}-color-hover);
+  color: var(${prefix}-color-textSecondary);
+  cursor: not-allowed;
+}
+`;
+}
+/**
+ * Theme presets
+ */
+const lightThemeVariables = `
+:root, [data-seekora-theme="light"] {
+  --seekora-color-primary: #0066cc;
+  --seekora-color-secondary: #6c757d;
+  --seekora-color-background: #ffffff;
+  --seekora-color-surface: #f8f9fa;
+  --seekora-color-text: #212529;
+  --seekora-color-textSecondary: #6c757d;
+  --seekora-color-border: #dee2e6;
+  --seekora-color-hover: #f1f3f5;
+  --seekora-color-focus: rgba(0, 102, 204, 0.25);
+  --seekora-color-error: #dc3545;
+  --seekora-color-success: #28a745;
+  --seekora-color-warning: #ffc107;
+  
+  --seekora-font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+  --seekora-font-size-small: 0.875rem;
+  --seekora-font-size-medium: 1rem;
+  --seekora-font-size-large: 1.25rem;
+  --seekora-font-weight-normal: 400;
+  --seekora-font-weight-medium: 500;
+  --seekora-font-weight-semibold: 600;
+  --seekora-font-weight-bold: 700;
+  --seekora-line-height-tight: 1.25;
+  --seekora-line-height-normal: 1.5;
+  --seekora-line-height-relaxed: 1.75;
+  
+  --seekora-spacing-small: 0.5rem;
+  --seekora-spacing-medium: 1rem;
+  --seekora-spacing-large: 1.5rem;
+  
+  --seekora-border-radius: 4px;
+  --seekora-border-radius-none: 0;
+  --seekora-border-radius-small: 2px;
+  --seekora-border-radius-medium: 4px;
+  --seekora-border-radius-large: 8px;
+  --seekora-border-radius-full: 9999px;
+  
+  --seekora-shadow-small: 0 1px 2px rgba(0, 0, 0, 0.05);
+  --seekora-shadow-medium: 0 4px 6px rgba(0, 0, 0, 0.1);
+  --seekora-shadow-large: 0 10px 15px rgba(0, 0, 0, 0.1);
+  
+  --seekora-transition-fast: 150ms ease-in-out;
+  --seekora-transition-normal: 300ms ease-in-out;
+  --seekora-transition-slow: 500ms ease-in-out;
+  
+  --seekora-z-index-dropdown: 1000;
+  --seekora-z-index-modal: 1050;
+  --seekora-z-index-tooltip: 1100;
+}
+`;
+const darkThemeVariables = `
+[data-seekora-theme="dark"] {
+  --seekora-color-primary: #4da6ff;
+  --seekora-color-secondary: #adb5bd;
+  --seekora-color-background: #1a1a1a;
+  --seekora-color-surface: #2d2d2d;
+  --seekora-color-text: #f8f9fa;
+  --seekora-color-textSecondary: #adb5bd;
+  --seekora-color-border: #495057;
+  --seekora-color-hover: #343a40;
+  --seekora-color-focus: rgba(77, 166, 255, 0.25);
+  --seekora-color-error: #f87171;
+  --seekora-color-success: #4ade80;
+  --seekora-color-warning: #fbbf24;
+  
+  --seekora-shadow-small: 0 1px 2px rgba(0, 0, 0, 0.3);
+  --seekora-shadow-medium: 0 4px 6px rgba(0, 0, 0, 0.4);
+  --seekora-shadow-large: 0 10px 15px rgba(0, 0, 0, 0.5);
+}
+`;
+const minimalThemeVariables = `
+[data-seekora-theme="minimal"] {
+  --seekora-color-primary: #000000;
+  --seekora-color-secondary: #666666;
+  --seekora-color-background: #ffffff;
+  --seekora-color-surface: #fafafa;
+  --seekora-color-text: #000000;
+  --seekora-color-textSecondary: #666666;
+  --seekora-color-border: #e5e5e5;
+  --seekora-color-hover: #f5f5f5;
+  --seekora-color-focus: rgba(0, 0, 0, 0.1);
+  
+  --seekora-border-radius: 0;
+  --seekora-border-radius-none: 0;
+  --seekora-border-radius-small: 0;
+  --seekora-border-radius-medium: 0;
+  --seekora-border-radius-large: 0;
+  --seekora-border-radius-full: 0;
+  
+  --seekora-shadow-small: none;
+  --seekora-shadow-medium: none;
+  --seekora-shadow-large: none;
+}
+`;
+const highContrastThemeVariables = `
+[data-seekora-theme="high-contrast"] {
+  --seekora-color-primary: #0000ff;
+  --seekora-color-secondary: #000000;
+  --seekora-color-background: #ffffff;
+  --seekora-color-surface: #ffffff;
+  --seekora-color-text: #000000;
+  --seekora-color-textSecondary: #000000;
+  --seekora-color-border: #000000;
+  --seekora-color-hover: #ffff00;
+  --seekora-color-focus: #0000ff;
+  --seekora-color-error: #ff0000;
+  --seekora-color-success: #008000;
+  --seekora-color-warning: #ffff00;
+  
+  --seekora-font-weight-normal: 500;
+  --seekora-font-weight-medium: 600;
+  --seekora-font-weight-semibold: 700;
+  --seekora-font-weight-bold: 900;
+}
+`;
+/**
+ * Complete stylesheet with all presets and component classes
+ */
+function generateCompleteStylesheet() {
+    return `
+/* Seekora UI SDK Styles */
+/* Generated CSS Variables and Component Classes */
+
+${lightThemeVariables}
+
+${darkThemeVariables}
+
+${minimalThemeVariables}
+
+${highContrastThemeVariables}
+
+${generateComponentClasses('--seekora')}
+`;
+}
+/**
+ * Inject styles into the document head
+ */
+function injectStyles(css, id = 'seekora-theme') {
+    if (typeof document === 'undefined')
+        return;
+    // Remove existing style if present
+    const existing = document.getElementById(id);
+    if (existing) {
+        existing.remove();
+    }
+    const style = document.createElement('style');
+    style.id = id;
+    style.textContent = css;
+    document.head.appendChild(style);
+}
+/**
+ * Set the active theme
+ */
+function setTheme(themeName) {
+    if (typeof document === 'undefined')
+        return;
+    document.documentElement.setAttribute('data-seekora-theme', themeName);
+}
+/**
+ * Get the current theme
+ */
+function getTheme() {
+    if (typeof document === 'undefined')
+        return 'light';
+    return document.documentElement.getAttribute('data-seekora-theme') || 'light';
+}
+
+/**
+ * Logger utility for Seekora UI SDK
+ *
+ * Provides structured logging with different log levels:
+ * - verbose: Detailed debugging information
+ * - info: General informational messages
+ * - warn: Warning messages for potential issues
+ * - error: Error messages for failures
+ */
+exports.LogLevel = void 0;
+(function (LogLevel) {
+    LogLevel[LogLevel["VERBOSE"] = 0] = "VERBOSE";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["SILENT"] = 4] = "SILENT";
+})(exports.LogLevel || (exports.LogLevel = {}));
+class Logger {
+    constructor(config = {}) {
+        this.level = config.level ?? this.getDefaultLevel();
+        this.prefix = config.prefix ?? '[Seekora UI SDK]';
+        this.enableTimestamp = config.enableTimestamp ?? false;
+    }
+    getDefaultLevel() {
+        // Check for environment variable or default to INFO
+        if (({})) {
+            const envLevel = undefined?.toUpperCase();
+            switch (envLevel) {
+                case 'VERBOSE':
+                    return exports.LogLevel.VERBOSE;
+                case 'INFO':
+                    return exports.LogLevel.INFO;
+                case 'WARN':
+                    return exports.LogLevel.WARN;
+                case 'ERROR':
+                    return exports.LogLevel.ERROR;
+                case 'SILENT':
+                    return exports.LogLevel.SILENT;
+            }
+        }
+        // Default to INFO in production, VERBOSE in development
+        if (typeof window !== 'undefined' && window.__SEEKORA_DEBUG__) {
+            return exports.LogLevel.VERBOSE;
+        }
+        return exports.LogLevel.INFO;
+    }
+    formatMessage(level, ...args) {
+        const parts = [];
+        if (this.enableTimestamp) {
+            parts.push(`[${new Date().toISOString()}]`);
+        }
+        parts.push(this.prefix, `[${level}]`);
+        return [...parts, ...args];
+    }
+    verbose(...args) {
+        if (this.level <= exports.LogLevel.VERBOSE) {
+            console.log(...this.formatMessage('VERBOSE', ...args));
+        }
+    }
+    info(...args) {
+        if (this.level <= exports.LogLevel.INFO) {
+            console.info(...this.formatMessage('INFO', ...args));
+        }
+    }
+    warn(...args) {
+        if (this.level <= exports.LogLevel.WARN) {
+            console.warn(...this.formatMessage('WARN', ...args));
+        }
+    }
+    error(...args) {
+        if (this.level <= exports.LogLevel.ERROR) {
+            console.error(...this.formatMessage('ERROR', ...args));
+        }
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    getLevel() {
+        return this.level;
+    }
+    setPrefix(prefix) {
+        this.prefix = prefix;
+    }
+    setTimestamp(enabled) {
+        this.enableTimestamp = enabled;
+    }
+}
+// Create default logger instance
+let defaultLogger = null;
+function createLogger(config = {}) {
+    return new Logger(config);
+}
+function getLogger() {
+    if (!defaultLogger) {
+        defaultLogger = createLogger();
+    }
+    return defaultLogger;
+}
+function setDefaultLogger(logger) {
+    defaultLogger = logger;
+}
+function setLogLevel(level) {
+    getLogger().setLevel(level);
+}
+function setLogPrefix(prefix) {
+    getLogger().setPrefix(prefix);
+}
+function setLogTimestamp(enabled) {
+    getLogger().setTimestamp(enabled);
+}
+// Convenience functions that use the default logger
+const log = {
+    verbose: (...args) => getLogger().verbose(...args),
+    info: (...args) => getLogger().info(...args),
+    warn: (...args) => getLogger().warn(...args),
+    error: (...args) => getLogger().error(...args),
+};
+// Export default logger instance
+getLogger();
+
+/**
+ * Highlight Utilities
+ *
+ * Core utilities for highlighting matching terms in search results
+ * Framework-agnostic functions shared across all packages
+ */
+/**
+ * Get highlighted value from a hit
+ * Looks for _highlightResult or highlight_result field
+ */
+function getHighlightedValue(options) {
+    const { attribute, hit, preTag = '<mark>', postTag = '</mark>', fallback, } = options;
+    // Check for various highlight result formats
+    const highlightResult = hit._highlightResult?.[attribute]?.value ||
+        hit.highlight_result?.[attribute]?.value ||
+        hit._highlight?.[attribute] ||
+        hit.highlight?.[attribute];
+    if (highlightResult) {
+        // Replace highlight markers with custom tags
+        return highlightResult
+            .replace(/<em>/g, preTag)
+            .replace(/<\/em>/g, postTag)
+            .replace(/<mark>/g, preTag)
+            .replace(/<\/mark>/g, postTag);
+    }
+    // Fall back to plain attribute value
+    const plainValue = getNestedValue(hit, attribute);
+    return plainValue !== undefined ? String(plainValue) : (fallback || '');
+}
+/**
+ * Get snippet (truncated highlighted value) from a hit
+ */
+function getSnippetedValue(options) {
+    const { attribute, hit, preTag = '<mark>', postTag = '</mark>', fallback, maxLength = 100, ellipsis = '...', } = options;
+    // Check for snippet result
+    const snippetResult = hit._snippetResult?.[attribute]?.value ||
+        hit.snippet_result?.[attribute]?.value ||
+        hit._snippet?.[attribute] ||
+        hit.snippet?.[attribute];
+    let text = '';
+    if (snippetResult) {
+        text = snippetResult
+            .replace(/<em>/g, preTag)
+            .replace(/<\/em>/g, postTag)
+            .replace(/<mark>/g, preTag)
+            .replace(/<\/mark>/g, postTag);
+    }
+    else {
+        // Fall back to highlighted or plain value
+        text = getHighlightedValue(options);
+    }
+    // Truncate if needed
+    if (text.length > maxLength) {
+        // Try to truncate at word boundary
+        const truncated = text.substring(0, maxLength);
+        const lastSpace = truncated.lastIndexOf(' ');
+        if (lastSpace > maxLength * 0.7) {
+            return truncated.substring(0, lastSpace) + ellipsis;
+        }
+        return truncated + ellipsis;
+    }
+    return text;
+}
+/**
+ * Parse highlighted value into parts for custom rendering
+ */
+function parseHighlightedParts(highlightedValue, preTag = '<mark>', postTag = '</mark>') {
+    const parts = [];
+    let remaining = highlightedValue;
+    while (remaining.length > 0) {
+        const startIdx = remaining.indexOf(preTag);
+        if (startIdx === -1) {
+            // No more highlights, add remaining as non-highlighted
+            if (remaining.length > 0) {
+                parts.push({ value: remaining, isHighlighted: false });
+            }
+            break;
+        }
+        // Add text before highlight
+        if (startIdx > 0) {
+            parts.push({ value: remaining.substring(0, startIdx), isHighlighted: false });
+        }
+        // Find end of highlight
+        const afterPreTag = remaining.substring(startIdx + preTag.length);
+        const endIdx = afterPreTag.indexOf(postTag);
+        if (endIdx === -1) {
+            // Malformed, add rest as non-highlighted
+            parts.push({ value: remaining.substring(startIdx), isHighlighted: false });
+            break;
+        }
+        // Add highlighted part
+        parts.push({ value: afterPreTag.substring(0, endIdx), isHighlighted: true });
+        // Continue with rest
+        remaining = afterPreTag.substring(endIdx + postTag.length);
+    }
+    return parts;
+}
+/**
+ * Highlight a query in text (client-side highlighting)
+ * Useful when server doesn't provide highlight data
+ */
+function highlightQuery(text, query, options = {}) {
+    const { preTag = '<mark>', postTag = '</mark>', caseSensitive = false } = options;
+    if (!query || !text)
+        return text;
+    const flags = caseSensitive ? 'g' : 'gi';
+    const escapedQuery = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(`(${escapedQuery})`, flags);
+    return text.replace(regex, `${preTag}$1${postTag}`);
+}
+/**
+ * Parse query-highlighted text into parts
+ */
+function parseQueryHighlightParts(text, query, caseSensitive = false) {
+    if (!query || !text) {
+        return [{ value: text, isHighlighted: false }];
+    }
+    const parts = [];
+    const flags = caseSensitive ? 'g' : 'gi';
+    const escapedQuery = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(escapedQuery, flags);
+    let lastIndex = 0;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        // Add text before match
+        if (match.index > lastIndex) {
+            parts.push({ value: text.substring(lastIndex, match.index), isHighlighted: false });
+        }
+        // Add highlighted match
+        parts.push({ value: match[0], isHighlighted: true });
+        lastIndex = regex.lastIndex;
+    }
+    // Add remaining text
+    if (lastIndex < text.length) {
+        parts.push({ value: text.substring(lastIndex), isHighlighted: false });
+    }
+    return parts.length > 0 ? parts : [{ value: text, isHighlighted: false }];
+}
+/**
+ * Get nested value from object using dot notation
+ */
+function getNestedValue(obj, path) {
+    return path.split('.').reduce((current, key) => {
+        return current && current[key] !== undefined ? current[key] : undefined;
+    }, obj);
+}
+/**
+ * Strip HTML tags from highlighted text
+ */
+function stripHighlightTags(text) {
+    return text
+        .replace(/<mark>/g, '')
+        .replace(/<\/mark>/g, '')
+        .replace(/<em>/g, '')
+        .replace(/<\/em>/g, '');
+}
+
+/**
+ * Accessibility Utilities
+ *
+ * Shared accessibility helpers for keyboard navigation, focus management,
+ * screen reader announcements, and ARIA attributes.
+ */
+// ============================================================================
+// Screen Reader Announcements (Live Regions)
+// ============================================================================
+let announcer = null;
+/**
+ * Create or get the screen reader announcer element
+ */
+function getAnnouncer() {
+    if (announcer)
+        return announcer;
+    if (typeof document === 'undefined') {
+        throw new Error('Cannot create announcer: document is undefined');
+    }
+    announcer = document.createElement('div');
+    announcer.id = 'seekora-announcer';
+    announcer.setAttribute('role', 'status');
+    announcer.setAttribute('aria-live', 'polite');
+    announcer.setAttribute('aria-atomic', 'true');
+    announcer.style.cssText = `
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border: 0;
+  `;
+    document.body.appendChild(announcer);
+    return announcer;
+}
+/**
+ * Announce a message to screen readers
+ */
+function announce(message, priority = 'polite') {
+    if (typeof document === 'undefined')
+        return;
+    try {
+        const el = getAnnouncer();
+        el.setAttribute('aria-live', priority);
+        // Clear and set message (needs a brief delay to trigger announcement)
+        el.textContent = '';
+        setTimeout(() => {
+            el.textContent = message;
+        }, 50);
+    }
+    catch (e) {
+        // Ignore errors in SSR
+    }
+}
+/**
+ * Announce search results count
+ */
+function announceResults(count, query) {
+    let message = '';
+    if (count === 0) {
+        message = query
+            ? `No results found for "${query}"`
+            : 'No results found';
+    }
+    else if (count === 1) {
+        message = query
+            ? `1 result found for "${query}"`
+            : '1 result found';
+    }
+    else {
+        message = query
+            ? `${count} results found for "${query}"`
+            : `${count} results found`;
+    }
+    announce(message);
+}
+/**
+ * Announce filter changes
+ */
+function announceFilterChange(action, filterName, filterValue) {
+    let message = '';
+    switch (action) {
+        case 'added':
+            message = `Filter ${filterName}: ${filterValue} applied`;
+            break;
+        case 'removed':
+            message = `Filter ${filterName}: ${filterValue} removed`;
+            break;
+        case 'cleared':
+            message = 'All filters cleared';
+            break;
+    }
+    announce(message);
+}
+/**
+ * Handle keyboard navigation for a list of items
+ */
+function handleKeyboardNavigation(event, options) {
+    const { items, activeIndex, onActiveChange, onSelect, onCancel, wrap = true, orientation = 'vertical', } = options;
+    const itemCount = items.length;
+    if (itemCount === 0)
+        return false;
+    let handled = false;
+    let newIndex = activeIndex;
+    switch (event.key) {
+        case 'ArrowDown':
+            if (orientation === 'vertical' || orientation === 'both') {
+                event.preventDefault();
+                if (activeIndex < itemCount - 1) {
+                    newIndex = activeIndex + 1;
+                }
+                else if (wrap) {
+                    newIndex = 0;
+                }
+                handled = true;
+            }
+            break;
+        case 'ArrowUp':
+            if (orientation === 'vertical' || orientation === 'both') {
+                event.preventDefault();
+                if (activeIndex > 0) {
+                    newIndex = activeIndex - 1;
+                }
+                else if (wrap) {
+                    newIndex = itemCount - 1;
+                }
+                handled = true;
+            }
+            break;
+        case 'ArrowRight':
+            if (orientation === 'horizontal' || orientation === 'both') {
+                event.preventDefault();
+                if (activeIndex < itemCount - 1) {
+                    newIndex = activeIndex + 1;
+                }
+                else if (wrap) {
+                    newIndex = 0;
+                }
+                handled = true;
+            }
+            break;
+        case 'ArrowLeft':
+            if (orientation === 'horizontal' || orientation === 'both') {
+                event.preventDefault();
+                if (activeIndex > 0) {
+                    newIndex = activeIndex - 1;
+                }
+                else if (wrap) {
+                    newIndex = itemCount - 1;
+                }
+                handled = true;
+            }
+            break;
+        case 'Home':
+            event.preventDefault();
+            newIndex = 0;
+            handled = true;
+            break;
+        case 'End':
+            event.preventDefault();
+            newIndex = itemCount - 1;
+            handled = true;
+            break;
+        case 'Enter':
+        case ' ':
+            event.preventDefault();
+            if (activeIndex >= 0 && onSelect) {
+                onSelect(activeIndex);
+            }
+            handled = true;
+            break;
+        case 'Escape':
+            if (onCancel) {
+                event.preventDefault();
+                onCancel();
+                handled = true;
+            }
+            break;
+    }
+    if (newIndex !== activeIndex && newIndex >= 0 && newIndex < itemCount) {
+        onActiveChange(newIndex);
+        // Focus the new item
+        const item = items[newIndex];
+        if (item) {
+            item.focus();
+        }
+    }
+    return handled;
+}
+/**
+ * Create a roving tabindex manager for accessible list navigation
+ */
+function createRovingTabIndex(container, selector) {
+    const items = Array.from(container.querySelectorAll(selector));
+    // Initialize: first item gets tabindex 0, others get -1
+    items.forEach((item, index) => {
+        item.setAttribute('tabindex', index === 0 ? '0' : '-1');
+    });
+    return {
+        update: (activeIndex) => {
+            items.forEach((item, index) => {
+                item.setAttribute('tabindex', index === activeIndex ? '0' : '-1');
+            });
+        },
+        destroy: () => {
+            items.forEach(item => {
+                item.removeAttribute('tabindex');
+            });
+        },
+    };
+}
+// ============================================================================
+// Focus Management
+// ============================================================================
+/**
+ * Get all focusable elements within a container
+ */
+function getFocusableElements(container) {
+    const selector = [
+        'button:not([disabled])',
+        '[href]',
+        'input:not([disabled])',
+        'select:not([disabled])',
+        'textarea:not([disabled])',
+        '[tabindex]:not([tabindex="-1"])',
+    ].join(', ');
+    return Array.from(container.querySelectorAll(selector));
+}
+/**
+ * Create a focus trap within a container (for modals/dialogs)
+ */
+function createFocusTrap(container) {
+    let previouslyFocused = null;
+    let handleKeyDown = null;
+    return {
+        activate: () => {
+            previouslyFocused = document.activeElement;
+            const focusable = getFocusableElements(container);
+            if (focusable.length === 0)
+                return;
+            const firstFocusable = focusable[0];
+            const lastFocusable = focusable[focusable.length - 1];
+            handleKeyDown = (e) => {
+                if (e.key !== 'Tab')
+                    return;
+                if (e.shiftKey) {
+                    if (document.activeElement === firstFocusable) {
+                        e.preventDefault();
+                        lastFocusable.focus();
+                    }
+                }
+                else {
+                    if (document.activeElement === lastFocusable) {
+                        e.preventDefault();
+                        firstFocusable.focus();
+                    }
+                }
+            };
+            document.addEventListener('keydown', handleKeyDown);
+            firstFocusable.focus();
+        },
+        deactivate: () => {
+            if (handleKeyDown) {
+                document.removeEventListener('keydown', handleKeyDown);
+                handleKeyDown = null;
+            }
+            if (previouslyFocused) {
+                previouslyFocused.focus();
+                previouslyFocused = null;
+            }
+        },
+    };
+}
+/**
+ * Focus first error or first input in a form
+ */
+function focusFirstError(container) {
+    const error = container.querySelector('[aria-invalid="true"]');
+    if (error) {
+        error.focus();
+        return true;
+    }
+    return false;
+}
+// ============================================================================
+// ARIA Helpers
+// ============================================================================
+/**
+ * Generate a unique ID for ARIA relationships
+ */
+let idCounter = 0;
+function generateId(prefix = 'seekora') {
+    return `${prefix}-${++idCounter}`;
+}
+/**
+ * Set up ARIA describedby relationship
+ */
+function setAriaDescribedBy(element, describer) {
+    const id = describer.id || generateId('description');
+    describer.id = id;
+    const existing = element.getAttribute('aria-describedby');
+    const newValue = existing ? `${existing} ${id}` : id;
+    element.setAttribute('aria-describedby', newValue);
+    return () => {
+        const current = element.getAttribute('aria-describedby');
+        if (current) {
+            const ids = current.split(' ').filter(i => i !== id);
+            if (ids.length > 0) {
+                element.setAttribute('aria-describedby', ids.join(' '));
+            }
+            else {
+                element.removeAttribute('aria-describedby');
+            }
+        }
+    };
+}
+/**
+ * Check if user prefers reduced motion
+ */
+function prefersReducedMotion() {
+    if (typeof window === 'undefined')
+        return false;
+    return window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+}
+/**
+ * Check if user prefers high contrast
+ */
+function prefersHighContrast() {
+    if (typeof window === 'undefined')
+        return false;
+    return window.matchMedia('(prefers-contrast: more)').matches;
+}
+/**
+ * Create a keyboard shortcuts manager
+ */
+function createKeyboardShortcuts(shortcuts) {
+    const handleKeyDown = (e) => {
+        for (const shortcut of shortcuts) {
+            const keyMatches = e.key.toLowerCase() === shortcut.key.toLowerCase();
+            const ctrlMatches = !shortcut.ctrl || e.ctrlKey;
+            const altMatches = !shortcut.alt || e.altKey;
+            const shiftMatches = !shortcut.shift || e.shiftKey;
+            const metaMatches = !shortcut.meta || e.metaKey;
+            if (keyMatches && ctrlMatches && altMatches && shiftMatches && metaMatches) {
+                e.preventDefault();
+                shortcut.handler(e);
+                break;
+            }
+        }
+    };
+    return {
+        attach: () => {
+            document.addEventListener('keydown', handleKeyDown);
+        },
+        detach: () => {
+            document.removeEventListener('keydown', handleKeyDown);
+        },
+        getShortcuts: () => [...shortcuts],
+    };
+}
+
+/**
+ * SearchStateManager
+ *
+ * Centralized state management for search operations
+ * Framework-agnostic core logic shared across all packages
+ * Handles query, refinements, pagination, sorting, and automatic search triggering
+ * Similar to InstantSearch.js architecture
+ */
+class SearchStateManager {
+    constructor(config) {
+        this.listeners = [];
+        this.debounceTimer = null;
+        this.client = config.client;
+        this.autoSearch = config.autoSearch !== false;
+        this.debounceMs = config.debounceMs || 300;
+        this.defaultSearchOptions = config.defaultSearchOptions || { widget_mode: true };
+        this.state = {
+            query: config.initialQuery || '',
+            refinements: [],
+            currentPage: 1,
+            itemsPerPage: config.itemsPerPage || 10,
+            sortBy: undefined,
+            results: null,
+            loading: false,
+            error: null,
+        };
+        log.info('SearchStateManager: Initialized', {
+            autoSearch: this.autoSearch,
+            debounceMs: this.debounceMs,
+        });
+    }
+    // State getters
+    getState() {
+        return { ...this.state };
+    }
+    getQuery() {
+        return this.state.query;
+    }
+    getRefinements() {
+        return [...this.state.refinements];
+    }
+    getCurrentPage() {
+        return this.state.currentPage;
+    }
+    getResults() {
+        return this.state.results;
+    }
+    getLoading() {
+        return this.state.loading;
+    }
+    getError() {
+        return this.state.error;
+    }
+    // State setters (automatically trigger search if autoSearch is enabled)
+    setQuery(query, triggerSearch = true) {
+        if (this.state.query === query) {
+            log.verbose('SearchStateManager: Query unchanged, skipping update', { query });
+            // Even if query is the same, trigger search if explicitly requested
+            if (triggerSearch && this.autoSearch) {
+                log.verbose('SearchStateManager: Query unchanged but triggerSearch=true, triggering search');
+                this.debouncedSearch();
+            }
+            return;
+        }
+        this.state.query = query;
+        this.state.currentPage = 1; // Reset to first page on new query
+        log.verbose('SearchStateManager: Query updated', { query, triggerSearch, autoSearch: this.autoSearch });
+        this.notifyListeners();
+        if (this.autoSearch && triggerSearch) {
+            log.verbose('SearchStateManager: Triggering debounced search');
+            this.debouncedSearch();
+        }
+        else {
+            log.verbose('SearchStateManager: Search not triggered', { autoSearch: this.autoSearch, triggerSearch });
+        }
+    }
+    addRefinement(field, value, triggerSearch = true) {
+        // Check if refinement already exists
+        const exists = this.state.refinements.some(r => r.field === field && r.value === value);
+        if (exists)
+            return;
+        this.state.refinements.push({ field, value });
+        this.state.currentPage = 1; // Reset to first page on filter change
+        log.verbose('SearchStateManager: Refinement added', { field, value });
+        this.notifyListeners();
+        if (this.autoSearch && triggerSearch) {
+            this.debouncedSearch();
+        }
+    }
+    removeRefinement(field, value, triggerSearch = true) {
+        const index = this.state.refinements.findIndex(r => r.field === field && r.value === value);
+        if (index === -1)
+            return;
+        this.state.refinements.splice(index, 1);
+        this.state.currentPage = 1; // Reset to first page on filter change
+        log.verbose('SearchStateManager: Refinement removed', { field, value });
+        this.notifyListeners();
+        if (this.autoSearch && triggerSearch) {
+            this.debouncedSearch();
+        }
+    }
+    clearRefinements(triggerSearch = true) {
+        if (this.state.refinements.length === 0)
+            return;
+        this.state.refinements = [];
+        this.state.currentPage = 1;
+        log.verbose('SearchStateManager: Refinements cleared');
+        this.notifyListeners();
+        if (this.autoSearch && triggerSearch) {
+            this.debouncedSearch();
+        }
+    }
+    setPage(page, triggerSearch = true) {
+        if (this.state.currentPage === page)
+            return;
+        this.state.currentPage = page;
+        log.verbose('SearchStateManager: Page updated', { page });
+        this.notifyListeners();
+        if (this.autoSearch && triggerSearch) {
+            this.debouncedSearch();
+        }
+    }
+    setSortBy(sortBy, triggerSearch = true) {
+        if (this.state.sortBy === sortBy)
+            return;
+        this.state.sortBy = sortBy;
+        this.state.currentPage = 1; // Reset to first page on sort change
+        log.verbose('SearchStateManager: Sort updated', { sortBy });
+        this.notifyListeners();
+        if (this.autoSearch && triggerSearch) {
+            this.debouncedSearch();
+        }
+    }
+    setItemsPerPage(itemsPerPage, triggerSearch = true) {
+        if (this.state.itemsPerPage === itemsPerPage)
+            return;
+        this.state.itemsPerPage = itemsPerPage;
+        this.state.currentPage = 1; // Reset to first page when changing items per page
+        log.verbose('SearchStateManager: Items per page updated', { itemsPerPage });
+        this.notifyListeners();
+        if (this.autoSearch && triggerSearch) {
+            this.debouncedSearch();
+        }
+    }
+    // Manual search trigger
+    async search(additionalOptions) {
+        // Clear debounce timer if exists
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        this.setState({ loading: true, error: null });
+        try {
+            const searchOptions = this.buildSearchOptions(additionalOptions);
+            log.verbose('SearchStateManager: Performing search', {
+                query: this.state.query,
+                refinementsCount: this.state.refinements.length,
+                currentPage: this.state.currentPage,
+                sortBy: this.state.sortBy,
+                filter_by: searchOptions.filter_by,
+            });
+            const response = await this.client.search(this.state.query, searchOptions);
+            this.setState({
+                results: response,
+                loading: false,
+                error: null,
+            });
+            log.info('SearchStateManager: Search completed', {
+                query: this.state.query,
+                resultsCount: response?.results?.length || 0,
+                totalResults: response?.totalResults || 0,
+            });
+            return response;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            this.setState({
+                results: null,
+                loading: false,
+                error,
+            });
+            log.error('SearchStateManager: Search failed', {
+                query: this.state.query,
+                error: error.message,
+            });
+            return null;
+        }
+    }
+    // Build search options from current state
+    buildSearchOptions(additionalOptions) {
+        const options = {
+            ...this.defaultSearchOptions,
+            page: this.state.currentPage,
+            per_page: this.state.itemsPerPage,
+            ...additionalOptions,
+        };
+        // Add sort_by if set and not "relevance" (relevance is the default, no sort field needed)
+        if (this.state.sortBy && this.state.sortBy !== 'relevance') {
+            options.sort_by = this.state.sortBy;
+        }
+        // Build filter_by from refinements
+        if (this.state.refinements.length > 0) {
+            const filtersByField = {};
+            this.state.refinements.forEach((refinement) => {
+                if (!filtersByField[refinement.field]) {
+                    filtersByField[refinement.field] = [];
+                }
+                filtersByField[refinement.field].push(refinement.value);
+            });
+            const filterParts = [];
+            Object.entries(filtersByField).forEach(([field, values]) => {
+                values.forEach((value) => {
+                    filterParts.push(`${field}:${value}`);
+                });
+            });
+            if (filterParts.length > 0) {
+                options.filter_by = filterParts.join(' && ');
+            }
+        }
+        return options;
+    }
+    // Debounced search trigger
+    debouncedSearch() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        log.verbose('SearchStateManager: Scheduling debounced search', { debounceMs: this.debounceMs });
+        this.debounceTimer = setTimeout(() => {
+            log.verbose('SearchStateManager: Debounce timer fired, calling search()');
+            this.search();
+        }, this.debounceMs);
+    }
+    // Subscribe to state changes
+    subscribe(listener) {
+        this.listeners.push(listener);
+        // Immediately call listener with current state
+        listener(this.getState());
+        // Return unsubscribe function
+        return () => {
+            this.listeners = this.listeners.filter(l => l !== listener);
+        };
+    }
+    // Update state and notify listeners
+    setState(updates) {
+        this.state = { ...this.state, ...updates };
+        this.notifyListeners();
+    }
+    // Notify all listeners of state changes
+    notifyListeners() {
+        const state = this.getState();
+        this.listeners.forEach(listener => {
+            try {
+                listener(state);
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                log.error('SearchStateManager: Error in listener', {
+                    error: error.message,
+                });
+            }
+        });
+    }
+    // Clear all state
+    clear() {
+        this.state = {
+            query: '',
+            refinements: [],
+            currentPage: 1,
+            itemsPerPage: this.state.itemsPerPage,
+            sortBy: undefined,
+            results: null,
+            loading: false,
+            error: null,
+        };
+        this.notifyListeners();
+    }
+}
+
+/**
+ * URL Router
+ *
+ * Syncs search state with browser URL for shareable links and back/forward navigation
+ * Framework-agnostic core logic shared across all packages
+ */
+class URLRouter {
+    constructor(config) {
+        this.unsubscribe = null;
+        this.debounceTimer = null;
+        this.isUpdatingFromUrl = false;
+        /**
+         * Handle browser back/forward navigation
+         */
+        this.handlePopState = () => {
+            if (this.readFromUrl) {
+                // Clear current refinements first
+                this.stateManager.clear();
+                this.readStateFromUrl();
+            }
+        };
+        this.stateManager = config.stateManager;
+        this.writeToUrl = config.writeToUrl !== false;
+        this.readFromUrl = config.readFromUrl !== false;
+        this.historyMode = config.historyMode || 'push';
+        this.debounceMs = config.debounceMs ?? 400;
+        this.basePath = config.basePath || (typeof window !== 'undefined' ? window.location.pathname : '/');
+        this.triggerSearchOnChange = config.triggerSearchOnChange !== false;
+        this.mapping = {
+            query: config.mapping?.query || 'q',
+            page: config.mapping?.page || 'page',
+            hitsPerPage: config.mapping?.hitsPerPage || 'hitsPerPage',
+            sortBy: config.mapping?.sortBy || 'sortBy',
+            refinementPrefix: config.mapping?.refinementPrefix || '',
+            refinementSerializer: config.mapping?.refinementSerializer,
+            refinementDeserializer: config.mapping?.refinementDeserializer,
+        };
+        // Initialize
+        this.init();
+    }
+    init() {
+        if (typeof window === 'undefined') {
+            log.warn('URLRouter: Not in browser environment, skipping initialization');
+            return;
+        }
+        // Read initial state from URL
+        if (this.readFromUrl) {
+            this.readStateFromUrl();
+        }
+        // Subscribe to state changes
+        if (this.writeToUrl) {
+            this.unsubscribe = this.stateManager.subscribe((state) => {
+                if (!this.isUpdatingFromUrl) {
+                    this.debouncedWriteToUrl(state);
+                }
+            });
+        }
+        // Listen for popstate (back/forward navigation)
+        window.addEventListener('popstate', this.handlePopState);
+        log.info('URLRouter: Initialized', {
+            writeToUrl: this.writeToUrl,
+            readFromUrl: this.readFromUrl,
+            historyMode: this.historyMode,
+        });
+    }
+    /**
+     * Read state from current URL and update StateManager
+     */
+    readStateFromUrl() {
+        const params = new URLSearchParams(window.location.search);
+        this.isUpdatingFromUrl = true;
+        try {
+            // Query
+            const query = params.get(this.mapping.query);
+            if (query !== null) {
+                this.stateManager.setQuery(query, false);
+            }
+            // Page
+            const page = params.get(this.mapping.page);
+            if (page !== null) {
+                const pageNum = parseInt(page, 10);
+                if (!isNaN(pageNum) && pageNum > 0) {
+                    this.stateManager.setPage(pageNum, false);
+                }
+            }
+            // Hits per page
+            const hitsPerPage = params.get(this.mapping.hitsPerPage);
+            if (hitsPerPage !== null) {
+                const hpp = parseInt(hitsPerPage, 10);
+                if (!isNaN(hpp) && hpp > 0) {
+                    this.stateManager.setItemsPerPage(hpp, false);
+                }
+            }
+            // Sort by
+            const sortBy = params.get(this.mapping.sortBy);
+            if (sortBy !== null) {
+                this.stateManager.setSortBy(sortBy, false);
+            }
+            // Refinements
+            const refinements = this.deserializeRefinements(params);
+            refinements.forEach(r => {
+                this.stateManager.addRefinement(r.field, r.value, false);
+            });
+            // Trigger search if there's any state
+            if (this.triggerSearchOnChange && (query || refinements.length > 0)) {
+                this.stateManager.search();
+            }
+            log.verbose('URLRouter: Read state from URL', {
+                query,
+                page,
+                refinements: refinements.length,
+            });
+        }
+        finally {
+            this.isUpdatingFromUrl = false;
+        }
+    }
+    /**
+     * Write state to URL
+     */
+    writeStateToUrl(state) {
+        const params = new URLSearchParams();
+        // Query
+        if (state.query) {
+            params.set(this.mapping.query, state.query);
+        }
+        // Page (only if not 1)
+        if (state.currentPage > 1) {
+            params.set(this.mapping.page, state.currentPage.toString());
+        }
+        // Hits per page (only if not default)
+        if (state.itemsPerPage !== 10) {
+            params.set(this.mapping.hitsPerPage, state.itemsPerPage.toString());
+        }
+        // Sort by
+        if (state.sortBy && state.sortBy !== 'relevance') {
+            params.set(this.mapping.sortBy, state.sortBy);
+        }
+        // Refinements
+        this.serializeRefinements(state.refinements, params);
+        // Build URL
+        const queryString = params.toString();
+        const url = queryString ? `${this.basePath}?${queryString}` : this.basePath;
+        // Update URL
+        if (this.historyMode === 'push') {
+            window.history.pushState({}, '', url);
+        }
+        else {
+            window.history.replaceState({}, '', url);
+        }
+        log.verbose('URLRouter: Wrote state to URL', { url });
+    }
+    /**
+     * Debounced write to URL
+     */
+    debouncedWriteToUrl(state) {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            this.writeStateToUrl(state);
+        }, this.debounceMs);
+    }
+    /**
+     * Serialize refinements to URL params
+     */
+    serializeRefinements(refinements, params) {
+        if (this.mapping.refinementSerializer) {
+            const serialized = this.mapping.refinementSerializer(refinements);
+            Object.entries(serialized).forEach(([key, value]) => {
+                params.set(key, value);
+            });
+            return;
+        }
+        // Default serialization: field[]=value
+        const byField = {};
+        refinements.forEach(r => {
+            const key = this.mapping.refinementPrefix + r.field;
+            if (!byField[key]) {
+                byField[key] = [];
+            }
+            byField[key].push(r.value);
+        });
+        Object.entries(byField).forEach(([field, values]) => {
+            values.forEach(value => {
+                params.append(field, value);
+            });
+        });
+    }
+    /**
+     * Deserialize refinements from URL params
+     */
+    deserializeRefinements(params) {
+        if (this.mapping.refinementDeserializer) {
+            return this.mapping.refinementDeserializer(params);
+        }
+        // Default deserialization
+        const refinements = [];
+        const knownParams = [
+            this.mapping.query,
+            this.mapping.page,
+            this.mapping.hitsPerPage,
+            this.mapping.sortBy,
+        ];
+        params.forEach((value, key) => {
+            // Skip known params
+            if (knownParams.includes(key))
+                return;
+            // Remove prefix if present
+            const field = this.mapping.refinementPrefix
+                ? key.replace(new RegExp(`^${this.mapping.refinementPrefix}`), '')
+                : key;
+            refinements.push({ field, value });
+        });
+        return refinements;
+    }
+    /**
+     * Manually update URL from current state
+     */
+    refresh() {
+        if (this.writeToUrl) {
+            this.writeStateToUrl(this.stateManager.getState());
+        }
+    }
+    /**
+     * Get current URL
+     */
+    getUrl() {
+        if (typeof window === 'undefined')
+            return '';
+        return window.location.href;
+    }
+    /**
+     * Generate shareable URL from state
+     */
+    createUrl(state) {
+        const currentState = this.stateManager.getState();
+        const mergedState = state ? { ...currentState, ...state } : currentState;
+        const params = new URLSearchParams();
+        if (mergedState.query) {
+            params.set(this.mapping.query, mergedState.query);
+        }
+        if (mergedState.currentPage > 1) {
+            params.set(this.mapping.page, mergedState.currentPage.toString());
+        }
+        if (mergedState.itemsPerPage !== 10) {
+            params.set(this.mapping.hitsPerPage, mergedState.itemsPerPage.toString());
+        }
+        if (mergedState.sortBy && mergedState.sortBy !== 'relevance') {
+            params.set(this.mapping.sortBy, mergedState.sortBy);
+        }
+        this.serializeRefinements(mergedState.refinements, params);
+        const queryString = params.toString();
+        const origin = typeof window !== 'undefined' ? window.location.origin : '';
+        return queryString ? `${origin}${this.basePath}?${queryString}` : `${origin}${this.basePath}`;
+    }
+    /**
+     * Destroy the router and cleanup
+     */
+    destroy() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (typeof window !== 'undefined') {
+            window.removeEventListener('popstate', this.handlePopState);
+        }
+        log.info('URLRouter: Destroyed');
+    }
+}
+/**
+ * Create a URL router instance
+ */
+function createURLRouter(config) {
+    return new URLRouter(config);
+}
+
+exports.SearchStateManager = SearchStateManager;
+exports.URLRouter = URLRouter;
+exports.announce = announce;
+exports.announceFilterChange = announceFilterChange;
+exports.announceResults = announceResults;
+exports.createFocusTrap = createFocusTrap;
+exports.createKeyboardShortcuts = createKeyboardShortcuts;
+exports.createLogger = createLogger;
+exports.createRovingTabIndex = createRovingTabIndex;
+exports.createTheme = createTheme;
+exports.createURLRouter = createURLRouter;
+exports.darkThemeVariables = darkThemeVariables;
+exports.extractField = extractField;
+exports.focusFirstError = focusFirstError;
+exports.formatPrice = formatPrice;
+exports.generateCompleteStylesheet = generateCompleteStylesheet;
+exports.generateId = generateId;
+exports.generateThemeStylesheet = generateThemeStylesheet;
+exports.getFocusableElements = getFocusableElements;
+exports.getHighlightedValue = getHighlightedValue;
+exports.getLogger = getLogger;
+exports.getNestedValue = getNestedValue$1;
+exports.getSnippetedValue = getSnippetedValue;
+exports.getTheme = getTheme;
+exports.handleKeyboardNavigation = handleKeyboardNavigation;
+exports.highContrastThemeVariables = highContrastThemeVariables;
+exports.highlightQuery = highlightQuery;
+exports.injectStyles = injectStyles;
+exports.lightThemeVariables = lightThemeVariables;
+exports.log = log;
+exports.mergeThemes = mergeThemes;
+exports.minimalThemeVariables = minimalThemeVariables;
+exports.parseHighlightedParts = parseHighlightedParts;
+exports.parseQueryHighlightParts = parseQueryHighlightParts;
+exports.prefersHighContrast = prefersHighContrast;
+exports.prefersReducedMotion = prefersReducedMotion;
+exports.setAriaDescribedBy = setAriaDescribedBy;
+exports.setDefaultLogger = setDefaultLogger;
+exports.setLogLevel = setLogLevel;
+exports.setLogPrefix = setLogPrefix;
+exports.setLogTimestamp = setLogTimestamp;
+exports.setTheme = setTheme;
+exports.stripHighlightTags = stripHighlightTags;
+exports.themeToCSSVariables = themeToCSSVariables;
+//# sourceMappingURL=index.js.map