@nuskin/react-search-sdk 1.0.0-comx-2233.1

package/dist/index.mjs

@@ -0,0 +1,1687 @@
+import React, { useState, useRef, useCallback, useEffect } from 'react';
+
+// src/constants.ts
+var STOREFRONT_SHOPPING_CONTEXT = "storefront";
+var CATALOG_SUGGESTIONS_PATH = "/storefront/catalogs/search/suggestions";
+var RECENT_SEARCHES_PREFIX = "nuskin:header:recentSearches";
+var RECENT_SEARCHES_DEFAULT_LIMIT = 10;
+var DEFAULT_SUGGESTION_PAGE = 1;
+var DEFAULT_SUGGESTION_SIZE = 6;
+var DEFAULT_SEARCH_PATH = "/search";
+var DEBOUNCE_MS = 220;
+var MAX_VISIBLE_SUGGESTIONS = 6;
+var SEARCH_PLACEHOLDER = "Search by product name, ingredient, benefits, or SKU";
+var TRIGGER_PLACEHOLDER = "Product Search";
+var DEFAULT_AI_CHAT_BASE_URL = "https://admin.tst.nuskin.ai/api/analytics/v1/chat";
+var DEFAULT_AI_CHAT_CONVERSATIONS_URL = `${DEFAULT_AI_CHAT_BASE_URL}/conversations`;
+var DEFAULT_AI_CHAT_MESSAGES_URL = `${DEFAULT_AI_CHAT_BASE_URL}/messages`;
+
+// src/services/SearchApiService.ts
+var DEFAULT_SEARCH_PLACEHOLDER = TRIGGER_PLACEHOLDER;
+var DEFAULT_INPUT_ARIA_LABEL = SEARCH_PLACEHOLDER;
+function canUseStorage(storage) {
+  return Boolean(storage) && typeof storage.getItem === "function";
+}
+function getSessionStorage(providedStorage) {
+  if (providedStorage) return providedStorage;
+  if (typeof window !== "undefined") {
+    try {
+      return window.sessionStorage;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function normalizeLocaleParts({
+  country,
+  language,
+  locale
+} = {}) {
+  const normalizedCountry = String(country ?? "").trim().toUpperCase();
+  const normalizedLanguage = String(language ?? "").trim().toLowerCase();
+  const normalizedLocale = String(locale ?? "").trim() || "UNKNOWN";
+  return {
+    country: normalizedCountry || "UNKNOWN",
+    language: normalizedLanguage || "unknown",
+    locale: normalizedLocale
+  };
+}
+function getRecentHeaderSearchesStorageKey(localeParts) {
+  const { country, language, locale } = normalizeLocaleParts(localeParts);
+  return `${RECENT_SEARCHES_PREFIX}:${locale}:${country}:${language}`;
+}
+function getRecentHeaderSearches(localeParts, storage) {
+  if (!canUseStorage(storage)) {
+    return [];
+  }
+  try {
+    const rawValue = storage.getItem(
+      getRecentHeaderSearchesStorageKey(localeParts)
+    );
+    if (!rawValue) {
+      return [];
+    }
+    const parsedValue = JSON.parse(rawValue);
+    if (!Array.isArray(parsedValue)) {
+      return [];
+    }
+    return parsedValue.map((item) => String(item ?? "").trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function addRecentHeaderSearch(localeParts, query, storage, limit = RECENT_SEARCHES_DEFAULT_LIMIT) {
+  const normalizedQuery = String(query ?? "").trim();
+  if (!normalizedQuery || !canUseStorage(storage)) {
+    return [];
+  }
+  try {
+    const existingValues = getRecentHeaderSearches(
+      localeParts,
+      storage
+    ).filter(
+      (item) => item.toLowerCase() !== normalizedQuery.toLowerCase()
+    );
+    const nextValues = [normalizedQuery, ...existingValues].slice(0, limit);
+    storage.setItem(
+      getRecentHeaderSearchesStorageKey(localeParts),
+      JSON.stringify(nextValues)
+    );
+    return nextValues;
+  } catch {
+    return [];
+  }
+}
+function clearRecentHeaderSearches(localeParts, storage) {
+  if (!canUseStorage(storage)) {
+    return;
+  }
+  try {
+    storage.removeItem(getRecentHeaderSearchesStorageKey(localeParts));
+  } catch {
+  }
+}
+function getBrowserLocation(providedLocation) {
+  if (providedLocation) return providedLocation;
+  if (typeof window !== "undefined" && window.location)
+    return window.location;
+  return null;
+}
+function resolveApiGatewayPath(apiGatewayPath, apiName = STOREFRONT_SHOPPING_CONTEXT) {
+  const apiGateway = String(apiGatewayPath ?? "").trim();
+  if (!apiGateway) return "";
+  return apiGateway.replace(/\{api_name\}/gi, apiName).replace(/\/$/, "");
+}
+function resolveCatalogApiBaseUrl(marketConfig) {
+  return resolveApiGatewayPath(marketConfig?.api_gateway_path);
+}
+function resolveCatalogStoreId(marketConfig) {
+  return String(marketConfig?.store_id ?? "").trim();
+}
+function buildCatalogSuggestionsUrl(apiBaseUrl) {
+  const normalizedBase = String(apiBaseUrl ?? "").trim().replace(/\/$/, "");
+  if (!normalizedBase) return "";
+  const suggestionsPath = normalizedBase.endsWith(
+    `/${STOREFRONT_SHOPPING_CONTEXT}`
+  ) ? "/catalogs/search/suggestions" : CATALOG_SUGGESTIONS_PATH;
+  return `${normalizedBase}${suggestionsPath}`;
+}
+function resolveSuggestionsUrl(suggestionsApi, locationLike) {
+  const pathOrUrl = String(suggestionsApi ?? "").trim();
+  if (!pathOrUrl) return "";
+  if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
+    return pathOrUrl;
+  }
+  const normalizedPath = pathOrUrl.startsWith("/") ? pathOrUrl : `/${pathOrUrl}`;
+  const origin = String(locationLike?.origin ?? "").trim();
+  return origin ? `${origin}${normalizedPath}` : normalizedPath;
+}
+async function resolveCatalogRequestConfig({
+  suggestionsApi,
+  storeIdOption,
+  locationLike,
+  country,
+  getMarketConfig
+}) {
+  const explicitStoreId = storeIdOption !== void 0 && storeIdOption !== null && String(storeIdOption).trim() !== "" ? String(storeIdOption).trim() : "";
+  const marketConfig = getMarketConfig ? await getMarketConfig({ locationLike, country }) ?? null : null;
+  const configuredApiBase = resolveCatalogApiBaseUrl(marketConfig);
+  const configuredStoreId = resolveCatalogStoreId(marketConfig);
+  const explicitSuggestionsApi = String(suggestionsApi ?? "").trim();
+  return {
+    suggestionsUrl: explicitSuggestionsApi ? resolveSuggestionsUrl(explicitSuggestionsApi, locationLike) : buildCatalogSuggestionsUrl(configuredApiBase),
+    storeId: explicitStoreId || configuredStoreId
+  };
+}
+function toCatalogLocale(localeParts) {
+  const language = String(localeParts.language ?? "en").toLowerCase();
+  const country = String(localeParts.country ?? "US").toUpperCase();
+  return `${language}_${country}`;
+}
+function buildSearchResultsPath(query, localeParts) {
+  const trimmedQuery = String(query ?? "").trim();
+  const hyphenatedQuery = trimmedQuery.replace(/\s+/g, "-");
+  const encodedQuery = encodeURIComponent(hyphenatedQuery).replace(
+    /%2D/gi,
+    "-"
+  );
+  const country = localeParts.country.toLowerCase();
+  const language = localeParts.language.toLowerCase();
+  return `/${country}/${language}${DEFAULT_SEARCH_PATH}/${encodedQuery}`;
+}
+function normalizeOptionUrl(rawValue) {
+  if (typeof rawValue !== "string") return "";
+  return rawValue.trim();
+}
+function safeDecodeURIComponent(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function trimEdgeHyphens(value) {
+  let normalizedValue = value;
+  while (normalizedValue.startsWith("-")) {
+    normalizedValue = normalizedValue.slice(1);
+  }
+  while (normalizedValue.endsWith("-")) {
+    normalizedValue = normalizedValue.slice(0, -1);
+  }
+  return normalizedValue;
+}
+function slugifyPathSegment(value) {
+  const decoded = safeDecodeURIComponent(String(value ?? "")).replace(
+    /\+/g,
+    " "
+  );
+  const normalized = decoded.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/-{2,}/g, "-").toLowerCase();
+  return trimEdgeHyphens(normalized);
+}
+function buildProductSlugPath(slugValue, localeParts) {
+  const slug = slugifyPathSegment(slugValue);
+  if (!slug) return "";
+  const country = String(localeParts.country ?? "US").toLowerCase();
+  const language = String(localeParts.language ?? "en").toLowerCase();
+  return `/${country}/${language}/product/${slug}`;
+}
+function isNavigableUrl(value) {
+  if (!value) return false;
+  return value.startsWith("/") || /^https?:\/\//i.test(value);
+}
+function stripLocalePrefix(path, localeParts) {
+  const prefix = `/${localeParts.country.toLowerCase()}/${localeParts.language.toLowerCase()}`;
+  return path.startsWith(prefix) ? path.slice(prefix.length) || "/" : path;
+}
+function resolveOptionHref(option, localeParts) {
+  const productSlugPath = buildProductSlugPath(
+    option?.slug ?? option?.productSlug ?? option?.product_slug ?? null,
+    localeParts
+  );
+  if (productSlugPath) {
+    return productSlugPath;
+  }
+  const directUrl = normalizeOptionUrl(option?.href ?? option?.url);
+  if (isNavigableUrl(directUrl) && !directUrl.includes("/chr/")) {
+    return directUrl;
+  }
+  return "";
+}
+async function fetchJsonFromCandidates(fetchImpl, requestUrls) {
+  let lastError;
+  for (const requestUrl of requestUrls) {
+    try {
+      const response = await fetchImpl(requestUrl, {
+        method: "GET",
+        credentials: "include",
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok) {
+        lastError = new Error(
+          `Request failed with status ${response.status}`
+        );
+        continue;
+      }
+      return await response.json();
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError ?? new Error("Unable to fetch header search data");
+}
+function createSearchService(options = {}) {
+  const {
+    fetchImpl: fetchImplOption,
+    location: providedLocation,
+    storage: providedStorage,
+    suggestionsApi,
+    storeId: storeIdOption,
+    country,
+    language,
+    locale,
+    searchPlaceholder = DEFAULT_SEARCH_PLACEHOLDER,
+    inputAriaLabel = DEFAULT_INPUT_ARIA_LABEL,
+    getMarketConfig
+  } = options;
+  const fetchImpl = fetchImplOption !== void 0 ? fetchImplOption : typeof fetch === "function" ? fetch.bind(globalThis) : null;
+  const locationLike = getBrowserLocation(providedLocation);
+  const storage = getSessionStorage(providedStorage);
+  const localeParts = normalizeLocaleParts({ country, language, locale });
+  let catalogRequestConfigPromise = null;
+  function loadCatalogRequestConfig() {
+    if (!catalogRequestConfigPromise) {
+      catalogRequestConfigPromise = resolveCatalogRequestConfig({
+        suggestionsApi,
+        storeIdOption,
+        locationLike,
+        country: localeParts.country,
+        getMarketConfig
+      });
+    }
+    return catalogRequestConfigPromise;
+  }
+  const service = {
+    async getSearchChromeCopy() {
+      return {
+        placeholder: searchPlaceholder || DEFAULT_SEARCH_PLACEHOLDER,
+        inputAriaLabel: inputAriaLabel || DEFAULT_INPUT_ARIA_LABEL
+      };
+    },
+    async fetchSuggestions(searchTerm) {
+      const trimmedSearchTerm = String(searchTerm ?? "").trim();
+      if (!trimmedSearchTerm || !fetchImpl) {
+        return {
+          suggestions: [],
+          didYouMean: [],
+          totalResultsCount: 0
+        };
+      }
+      const { suggestionsUrl, storeId } = await loadCatalogRequestConfig();
+      if (!suggestionsUrl || !storeId) {
+        return {
+          suggestions: [],
+          didYouMean: [],
+          totalResultsCount: 0
+        };
+      }
+      const queryParams = new URLSearchParams({
+        searchTerm: trimmedSearchTerm,
+        page: String(DEFAULT_SUGGESTION_PAGE),
+        size: String(DEFAULT_SUGGESTION_SIZE),
+        locale: toCatalogLocale(localeParts),
+        storeId: String(storeId)
+      });
+      const requestUrls = [`${suggestionsUrl}?${queryParams.toString()}`];
+      const responsePayload = await fetchJsonFromCandidates(
+        fetchImpl,
+        requestUrls
+      );
+      const suggestionsField = Array.isArray(responsePayload?.suggestions) ? responsePayload?.suggestions : [];
+      const productField = Array.isArray(responsePayload?.product) ? responsePayload?.product : null;
+      const rawDidYouMean = responsePayload?.didYouMean ?? responsePayload?.did_you_mean;
+      const didYouMeanField = Array.isArray(rawDidYouMean) ? rawDidYouMean : [];
+      const pageableTotal = Number(
+        responsePayload?.pageableInfo?.totalCount ?? Number.NaN
+      );
+      const totalResultsCount = typeof responsePayload?.totalResultsCount === "number" ? responsePayload.totalResultsCount : !Number.isNaN(pageableTotal) ? pageableTotal : productField?.length ?? suggestionsField.length;
+      return {
+        ...responsePayload ?? {},
+        suggestions: suggestionsField,
+        didYouMean: didYouMeanField,
+        totalResultsCount
+      };
+    },
+    submitProductSearch(query, option) {
+      const trimmedQuery = String(query ?? "").trim();
+      if (!trimmedQuery) return void 0;
+      addRecentHeaderSearch(localeParts, trimmedQuery, storage);
+      const optionHref = resolveOptionHref(option, localeParts);
+      if (optionHref && locationLike && typeof locationLike.assign === "function") {
+        locationLike.assign(optionHref);
+        return stripLocalePrefix(optionHref, localeParts);
+      }
+      const targetPath = buildSearchResultsPath(
+        trimmedQuery,
+        localeParts
+      );
+      if (locationLike && typeof locationLike.assign === "function") {
+        locationLike.assign(targetPath);
+      }
+      return stripLocalePrefix(targetPath, localeParts);
+    },
+    activateSuggestionAction(option) {
+      if (options.onSuggestionAction) {
+        const result = options.onSuggestionAction(option);
+        if (result instanceof Promise) {
+          result.then((handled) => {
+            if (!handled) {
+              const optionHref2 = resolveOptionHref(
+                option,
+                localeParts
+              );
+              if (optionHref2 && locationLike && typeof locationLike.assign === "function") {
+                locationLike.assign(optionHref2);
+              } else {
+                const optionQuery2 = option?.value ?? option?.label ?? option?.identifier ?? "";
+                service.submitProductSearch(
+                  String(optionQuery2)
+                );
+              }
+            }
+          }).catch((error) => {
+            console.error(
+              "Error in onSuggestionAction:",
+              error
+            );
+          });
+          return "action-pending";
+        } else if (result === true) {
+          return "action-handled";
+        }
+      }
+      const optionHref = resolveOptionHref(option, localeParts);
+      if (optionHref && locationLike && typeof locationLike.assign === "function") {
+        locationLike.assign(optionHref);
+        return optionHref;
+      }
+      const optionQuery = option?.value ?? option?.label ?? option?.identifier ?? "";
+      return service.submitProductSearch(String(optionQuery));
+    },
+    getSuggestionHref(option) {
+      return stripLocalePrefix(
+        resolveOptionHref(option, localeParts),
+        localeParts
+      );
+    },
+    viewMoreResults({ query }) {
+      return service.submitProductSearch(query);
+    },
+    getRecentSearches() {
+      return getRecentHeaderSearches(localeParts, storage);
+    },
+    clearRecentSearches() {
+      clearRecentHeaderSearches(localeParts, storage);
+    }
+  };
+  return service;
+}
+
+// node_modules/eventsource-parser/dist/errors.js
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "ParseError";
+    this.type = options.type;
+    this.field = options.field;
+    this.value = options.value;
+    this.line = options.line;
+  }
+};
+
+// node_modules/eventsource-parser/dist/parse.js
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+var MAX_FIELD_PREFIX_LENGTH = 6;
+function noop(_arg) {
+}
+function createParser(config) {
+  if (typeof config === "function") {
+    throw new TypeError("`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?");
+  }
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config;
+  const pendingFragments = [];
+  let pendingFragmentsLength = 0;
+  let isFirstChunk = true;
+  let id;
+  let data = "";
+  let dataLines = 0;
+  let eventType;
+  let terminated = false;
+  let skippingLine = false;
+  let skipNextLineFeed = false;
+  function feed(chunk) {
+    if (terminated) {
+      throw new Error("Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing.");
+    }
+    if (isFirstChunk) {
+      isFirstChunk = false;
+      if (chunk.charCodeAt(0) === 65279) {
+        chunk = chunk.slice(1);
+      } else if (chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191) {
+        chunk = chunk.slice(3);
+      }
+    }
+    if (skippingLine || skipNextLineFeed) {
+      chunk = resumeAfterSkip(chunk);
+      if (!chunk) {
+        return;
+      }
+    }
+    if (!pendingFragments.length) {
+      const trailing = processLines(chunk);
+      if (trailing !== "") {
+        storeTrailing(trailing);
+      }
+      checkBufferSize();
+      return;
+    }
+    if (chunk.indexOf("\n") === -1 && chunk.indexOf("\r") === -1) {
+      if (pendingFragmentsLength < MAX_FIELD_PREFIX_LENGTH) {
+        const head = pendingFragments.join("") + chunk.slice(0, MAX_FIELD_PREFIX_LENGTH - pendingFragmentsLength);
+        if (!shouldBufferTrailing(head)) {
+          pendingFragments.length = 0;
+          pendingFragmentsLength = 0;
+          skippingLine = true;
+          return;
+        }
+      }
+      pendingFragments.push(chunk);
+      pendingFragmentsLength += chunk.length;
+      checkBufferSize();
+      return;
+    }
+    pendingFragments.push(chunk);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0;
+    pendingFragmentsLength = 0;
+    storeTrailing(processLines(input));
+    checkBufferSize();
+  }
+  function resumeAfterSkip(chunk) {
+    if (chunk.length === 0) {
+      return chunk;
+    }
+    if (skipNextLineFeed) {
+      skipNextLineFeed = false;
+      return chunk.charCodeAt(0) === LF ? chunk.slice(1) : chunk;
+    }
+    const crIndex = chunk.indexOf("\r");
+    const lfIndex = chunk.indexOf("\n");
+    const lineEnd = crIndex === -1 ? lfIndex : lfIndex === -1 ? crIndex : crIndex < lfIndex ? crIndex : lfIndex;
+    if (lineEnd === -1) {
+      return "";
+    }
+    if (lineEnd === chunk.length - 1 && chunk.charCodeAt(lineEnd) === CR) {
+      skippingLine = false;
+      skipNextLineFeed = true;
+      return "";
+    }
+    skippingLine = false;
+    return chunk.slice(lineEnd + (chunk.charCodeAt(lineEnd) === CR && chunk.charCodeAt(lineEnd + 1) === LF ? 2 : 1));
+  }
+  function storeTrailing(trailing) {
+    if (!trailing)
+      return;
+    if (trailing.charCodeAt(trailing.length - 1) === CR) {
+      parseLine(trailing, 0, trailing.length - 1);
+      skipNextLineFeed = true;
+      return;
+    }
+    if (shouldBufferTrailing(trailing)) {
+      pendingFragments.push(trailing);
+      pendingFragmentsLength = trailing.length;
+      return;
+    }
+    skippingLine = true;
+  }
+  function shouldBufferTrailing(trailing) {
+    const firstCharCode = trailing.charCodeAt(0);
+    return firstCharCode === 58 && !!onComment || firstCharCode === 100 && isPotentialField(trailing, "data") || firstCharCode === 101 && isPotentialField(trailing, "event") || firstCharCode === 105 && isPotentialField(trailing, "id") || firstCharCode === 114 && isPotentialField(trailing, "retry");
+  }
+  function checkBufferSize() {
+    if (maxBufferSize === void 0)
+      return;
+    if (pendingFragmentsLength + data.length <= maxBufferSize)
+      return;
+    terminated = true;
+    pendingFragments.length = 0;
+    pendingFragmentsLength = 0;
+    id = void 0;
+    data = "";
+    dataLines = 0;
+    eventType = void 0;
+    skippingLine = false;
+    skipNextLineFeed = false;
+    onError(new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
+      type: "max-buffer-size-exceeded"
+    }));
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf("\n", searchIndex);
+      while (lfIndex !== -1) {
+        if (searchIndex === lfIndex) {
+          if (dataLines > 0) {
+            onEvent({ id, event: eventType, data });
+          }
+          id = void 0;
+          data = "";
+          dataLines = 0;
+          eventType = void 0;
+          searchIndex = lfIndex + 1;
+          lfIndex = chunk.indexOf("\n", searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5;
+          const value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            onEvent({ id, event: eventType, data: value });
+            id = void 0;
+            data = "";
+            eventType = void 0;
+            searchIndex = lfIndex + 2;
+            lfIndex = chunk.indexOf("\n", searchIndex);
+            continue;
+          }
+          data = dataLines === 0 ? value : `${data}
+${value}`;
+          dataLines++;
+        } else if (isEventPrefix(chunk, searchIndex, firstCharCode)) {
+          eventType = chunk.slice(chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6, lfIndex) || void 0;
+        } else {
+          parseLine(chunk, searchIndex, lfIndex);
+        }
+        searchIndex = lfIndex + 1;
+        lfIndex = chunk.indexOf("\n", searchIndex);
+      }
+      return chunk.slice(searchIndex);
+    }
+    while (searchIndex < chunk.length) {
+      const crIndex = chunk.indexOf("\r", searchIndex);
+      const lfIndex = chunk.indexOf("\n", searchIndex);
+      let lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1) {
+        lineEnd = crIndex < lfIndex ? crIndex : lfIndex;
+      } else if (crIndex !== -1) {
+        if (crIndex === chunk.length - 1) {
+          lineEnd = -1;
+        } else {
+          lineEnd = crIndex;
+        }
+      } else if (lfIndex !== -1) {
+        lineEnd = lfIndex;
+      }
+      if (lineEnd === -1) {
+        break;
+      }
+      parseLine(chunk, searchIndex, lineEnd);
+      searchIndex = lineEnd + 1;
+      if (chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF) {
+        searchIndex++;
+      }
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start, end) {
+    if (start === end) {
+      dispatchEvent();
+      return;
+    }
+    const firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5;
+      const value2 = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value2 : `${data}
+${value2}`;
+      dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      if (!value2.includes("\0"))
+        id = value2;
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line2 = chunk.slice(start, end);
+        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start, end);
+    const fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex);
+    const offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1;
+    const value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || void 0;
+        break;
+      case "data":
+        data = dataLines === 0 ? value : `${data}
+${value}`;
+        dataLines++;
+        break;
+      case "id":
+        if (!value.includes("\0"))
+          id = value;
+        break;
+      case "retry":
+        if (/^\d+$/.test(value)) {
+          onRetry(parseInt(value, 10));
+        } else {
+          onError(new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          }));
+        }
+        break;
+      default:
+        onError(new ParseError(`Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`, { type: "unknown-field", field, value, line }));
+        break;
+    }
+  }
+  function dispatchEvent() {
+    if (dataLines > 0) {
+      onEvent({
+        id,
+        event: eventType,
+        data
+      });
+    }
+    id = void 0;
+    data = "";
+    dataLines = 0;
+    eventType = void 0;
+  }
+  function reset(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = true;
+    id = void 0;
+    data = "";
+    dataLines = 0;
+    eventType = void 0;
+    pendingFragments.length = 0;
+    pendingFragmentsLength = 0;
+    terminated = false;
+    skippingLine = false;
+    skipNextLineFeed = false;
+  }
+  return { feed, reset };
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+function isPotentialField(line, field) {
+  let i = 1;
+  while (i < line.length && i < field.length) {
+    if (line.charCodeAt(i) !== field.charCodeAt(i)) {
+      return false;
+    }
+    i++;
+  }
+  return line.length <= field.length || line.charCodeAt(field.length) === 58;
+}
+
+// src/services/ChatService.ts
+var PRODUCTS_OPENING_FENCE = "```products";
+var MARKDOWN_CLOSING_FENCE = "\n```";
+function findProductsBlockStart(content, openingFenceIndex) {
+  let blockStart = openingFenceIndex + PRODUCTS_OPENING_FENCE.length;
+  while (blockStart < content.length && (content[blockStart] === " " || content[blockStart] === "	" || content[blockStart] === "\r")) {
+    blockStart += 1;
+  }
+  return content[blockStart] === "\n" ? blockStart + 1 : null;
+}
+function isStandaloneClosingFence(content, fenceEnd) {
+  const lineEnd = content.indexOf("\n", fenceEnd);
+  const suffixEnd = lineEnd === -1 ? content.length : lineEnd;
+  return content.slice(fenceEnd, suffixEnd).trim() === "";
+}
+function findClosingFence(content, fromIndex) {
+  let candidate = content.indexOf(MARKDOWN_CLOSING_FENCE, fromIndex);
+  while (candidate !== -1) {
+    const fenceEnd = candidate + MARKDOWN_CLOSING_FENCE.length;
+    if (isStandaloneClosingFence(content, fenceEnd)) {
+      return candidate;
+    }
+    candidate = content.indexOf(MARKDOWN_CLOSING_FENCE, fenceEnd);
+  }
+  return -1;
+}
+function extractProductsFromMarkdown(content) {
+  const products = [];
+  const summaryParts = [];
+  let summaryCursor = 0;
+  let searchCursor = 0;
+  while (searchCursor < content.length) {
+    const start = content.indexOf(PRODUCTS_OPENING_FENCE, searchCursor);
+    if (start === -1) break;
+    const blockStart = findProductsBlockStart(content, start);
+    if (blockStart === null) {
+      searchCursor = start + PRODUCTS_OPENING_FENCE.length;
+      continue;
+    }
+    const nextOpeningFence = content.indexOf(
+      PRODUCTS_OPENING_FENCE,
+      blockStart
+    );
+    const end = findClosingFence(content, blockStart);
+    if (end === -1) break;
+    if (nextOpeningFence !== -1 && nextOpeningFence < end) {
+      searchCursor = nextOpeningFence;
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(content.slice(blockStart, end));
+      if (Array.isArray(parsed)) {
+        products.push(...parsed);
+      }
+    } catch {
+    }
+    summaryParts.push(content.slice(summaryCursor, start));
+    summaryCursor = end + MARKDOWN_CLOSING_FENCE.length;
+    searchCursor = summaryCursor;
+  }
+  summaryParts.push(content.slice(summaryCursor));
+  return { summary: summaryParts.join("").trim(), products };
+}
+function createChatService(options) {
+  const {
+    conversationsUrl = DEFAULT_AI_CHAT_CONVERSATIONS_URL,
+    messagesUrl = DEFAULT_AI_CHAT_MESSAGES_URL,
+    tenantId,
+    getAuthToken,
+    fetchImpl: fetchImplOption
+  } = options;
+  let fetchImpl;
+  if (fetchImplOption !== void 0) {
+    fetchImpl = fetchImplOption;
+  } else if (typeof fetch === "function") {
+    fetchImpl = fetch.bind(globalThis);
+  } else {
+    fetchImpl = () => {
+      throw new Error("ChatService: no fetch implementation available");
+    };
+  }
+  function buildHeaders(extra) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...extra
+    };
+    if (tenantId) headers["X-Tenant-Id"] = tenantId;
+    const token = getAuthToken?.();
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+    return headers;
+  }
+  return {
+    async createConversation(title = "Search Session") {
+      const res = await fetchImpl(conversationsUrl, {
+        method: "POST",
+        headers: buildHeaders(),
+        body: JSON.stringify({ title })
+      });
+      if (!res.ok) {
+        throw new Error(
+          `ChatService.createConversation: ${res.status} ${res.statusText}`
+        );
+      }
+      const data = await res.json();
+      const id = data["id"] ?? data["conversation_id"];
+      if (typeof id !== "number") {
+        throw new TypeError(
+          "ChatService.createConversation: response missing numeric id"
+        );
+      }
+      return id;
+    },
+    async sendMessage(conversationId, content, onChunk) {
+      const res = await fetchImpl(messagesUrl, {
+        method: "POST",
+        headers: buildHeaders({ Accept: "application/json" }),
+        body: JSON.stringify({
+          conversation_id: conversationId,
+          content,
+          compact: false
+        })
+      });
+      if (!res.ok) {
+        throw new Error(
+          `ChatService.sendMessage: ${res.status} ${res.statusText}`
+        );
+      }
+      let accumulated = "";
+      const parser = createParser({
+        onEvent(event) {
+          const data = event.data;
+          if (!data || data === "[DONE]") return;
+          try {
+            const parsed = JSON.parse(data);
+            const parsedType = parsed["type"];
+            const type = typeof parsedType === "string" ? parsedType : "";
+            if (type === "content" && typeof parsed["text"] === "string") {
+              const text = parsed["text"];
+              accumulated += text;
+              onChunk?.(type, text);
+            } else if (type === "status" && typeof parsed["message"] === "string") {
+              const message = parsed["message"];
+              onChunk?.(type, message);
+            }
+          } catch {
+          }
+        }
+      });
+      const body = res.body;
+      if (body && typeof body.getReader === "function") {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          parser.feed(decoder.decode(value, { stream: true }));
+        }
+        parser.feed(decoder.decode());
+      } else {
+        const rawBody = await res.text();
+        parser.feed(rawBody);
+      }
+      const { summary, products } = extractProductsFromMarkdown(accumulated);
+      return { summary, products, rawContent: accumulated };
+    }
+  };
+}
+
+// src/utils/catalogHelpers.ts
+var CART_DISABLED_PRODUCT_STATUSES = /* @__PURE__ */ new Set([
+  "discontinued",
+  "preview",
+  "previewproduct",
+  "test",
+  "stopped",
+  "replacement",
+  "bundleonly",
+  "inactive",
+  "notavailable"
+]);
+function normalizeProductStatusValue(value) {
+  return String(value ?? "").trim().toLowerCase().replace(/\s+/g, "");
+}
+function isSellableProductStatus(productStatus) {
+  return normalizeProductStatusValue(productStatus) === "sellable";
+}
+function resolveSkuStatusValues(suggestionOption) {
+  return [
+    suggestionOption["productStatus"],
+    suggestionOption["product_status"],
+    suggestionOption["status"],
+    suggestionOption["sku_status"]
+  ].map(normalizeProductStatusValue).filter(Boolean);
+}
+function isNonSellableStatusValue(statusValue) {
+  if (CART_DISABLED_PRODUCT_STATUSES.has(statusValue)) {
+    return true;
+  }
+  return statusValue !== "sellable" && statusValue !== "active";
+}
+function isCartActionDisabled(suggestionOption) {
+  if (!suggestionOption) {
+    return true;
+  }
+  const outOfStock = suggestionOption["out_of_stock"] ?? suggestionOption["outOfStock"];
+  if (outOfStock) {
+    return true;
+  }
+  const statusValues = resolveSkuStatusValues(suggestionOption);
+  if (statusValues.length === 0) {
+    return false;
+  }
+  return statusValues.some(isNonSellableStatusValue);
+}
+function isSuggestionDisabled(suggestionOption) {
+  return Boolean(
+    !suggestionOption || suggestionOption["out_of_stock"] || suggestionOption["outOfStock"]
+  );
+}
+function getImageFromProperty(properties = {}) {
+  let image = String(properties["primaryimage"] ?? "").trim() || String(properties["imageURL"] ?? "").trim();
+  if (!image) {
+    try {
+      const parsed = JSON.parse(
+        String(properties["productImages"] ?? "{}")
+      );
+      if (Array.isArray(parsed) && parsed[0] && typeof parsed[0] === "object") {
+        image = String(
+          parsed[0]["url"] ?? ""
+        ).trim();
+      }
+    } catch {
+      image = "";
+    }
+  }
+  return image;
+}
+function resolveSuggestionImageSrc(imageSrc) {
+  const trimmed = typeof imageSrc === "string" ? imageSrc.trim() : String(imageSrc ?? "").trim();
+  return trimmed;
+}
+function safeParseJsonArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value !== "string" || !value.trim()) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function getIngredientTerms(rawIngredients) {
+  const ingredientGroups = safeParseJsonArray(rawIngredients);
+  return ingredientGroups.flatMap((ingredientGroup) => {
+    if (!ingredientGroup || typeof ingredientGroup !== "object") {
+      return [];
+    }
+    const group = ingredientGroup;
+    const keyIngredients = Array.isArray(group["keyIngredients"]) ? group["keyIngredients"].map((ingredient) => ingredient["name"]) : [];
+    return [
+      group["productName"],
+      group["activeIngredients"],
+      group["inactiveIngredients"],
+      group["allIngredients"],
+      group["otherIngredients"],
+      ...keyIngredients
+    ];
+  }).filter(Boolean).map((term) => String(term).trim()).filter(Boolean);
+}
+function getSkuProperties(product) {
+  const skuList = Array.isArray(product["sku"]) ? product["sku"] : [];
+  const defaultSku = skuList.find((skuEntry) => skuEntry?.["default"] === true) ?? skuList[0] ?? null;
+  return {
+    defaultSku: defaultSku ?? null,
+    skuProperties: defaultSku?.["properties"] ?? {}
+  };
+}
+function getIdentifier(product, defaultSku, index) {
+  return String(
+    defaultSku?.["identifier"] ?? product["identifier"] ?? `catalog-product-${index}`
+  ).trim();
+}
+function getDisplayLabel(identifier, productProperties, skuProperties) {
+  return String(
+    skuProperties["title"] ?? productProperties["name"] ?? productProperties["title"] ?? skuProperties["name"] ?? identifier
+  );
+}
+function getTypeData(product, productProperties, skuProperties) {
+  const customProductType = String(
+    productProperties["customProductType"] ?? skuProperties["customProductType"] ?? ""
+  ).trim();
+  const normalizedType = String(
+    product["type"] ?? productProperties["producttype"] ?? skuProperties["producttype"] ?? ""
+  ).trim().toLowerCase();
+  return {
+    customProductType,
+    isBundle: normalizedType === "bundle" || customProductType.toLowerCase().includes("bundle")
+  };
+}
+function getNavigationUrls(productProperties, skuProperties) {
+  const slug = String(
+    skuProperties["slug"] ?? productProperties["slug"] ?? ""
+  ).trim() || null;
+  const navigableUrl = String(
+    skuProperties["url"] ?? skuProperties["href"] ?? productProperties["url"] ?? productProperties["href"] ?? ""
+  ).trim() || null;
+  return { navigableUrl, slug };
+}
+function isOutOfStock(inventoryStatus) {
+  return String(inventoryStatus).toUpperCase() === "OUT OF STOCK";
+}
+function getCatalogStatusFields(skuProperties, productProperties) {
+  const inventoryStatus = skuProperties["inventoryStatus"] ?? productProperties["inventoryStatus"] ?? "";
+  const productStatus = skuProperties["productStatus"] ?? productProperties["productStatus"] ?? "";
+  const skuStatus = skuProperties["status"] ?? productProperties["status"] ?? "";
+  const normalizedProductStatus = String(productStatus).trim();
+  const normalizedSkuStatus = String(skuStatus).trim();
+  const outOfStock = isOutOfStock(inventoryStatus);
+  return {
+    normalizedProductStatus,
+    normalizedSkuStatus,
+    outOfStock,
+    cartActionDisabled: isCartActionDisabled({
+      outOfStock,
+      productStatus: normalizedProductStatus || void 0,
+      status: normalizedSkuStatus || void 0
+    })
+  };
+}
+function optionalNonEmptyString(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || void 0;
+}
+function getProductImageSrc(opts) {
+  const normalizedType = String(opts.product["type"] ?? "").trim().toLowerCase();
+  if (normalizedType === "kit" || normalizedType === "bundle") {
+    return getImageFromProperty(opts.productProperties);
+  }
+  return getImageFromProperty(opts.skuProperties);
+}
+function mapCatalogProductToSuggestion(product, index = 0) {
+  if (!product || typeof product !== "object") {
+    return null;
+  }
+  const p = product;
+  const productProperties = p["properties"] ?? {};
+  const { defaultSku, skuProperties } = getSkuProperties(p);
+  const identifier = getIdentifier(p, defaultSku, index);
+  const { customProductType, isBundle } = getTypeData(
+    p,
+    productProperties,
+    skuProperties
+  );
+  const { navigableUrl, slug } = getNavigationUrls(
+    productProperties,
+    skuProperties
+  );
+  const statusFields = getCatalogStatusFields(
+    skuProperties,
+    productProperties
+  );
+  const imageSrc = resolveSuggestionImageSrc(
+    getProductImageSrc({ product: p, productProperties, skuProperties })
+  );
+  const mappedProductType = isBundle ? "bundle" : "single";
+  return {
+    id: identifier,
+    identifier,
+    sku: identifier,
+    label: getDisplayLabel(identifier, productProperties, skuProperties),
+    value: getDisplayLabel(identifier, productProperties, skuProperties),
+    imageURL: imageSrc,
+    thumbnail: imageSrc,
+    productType: mappedProductType,
+    product_type: mappedProductType,
+    outOfStock: statusFields.outOfStock,
+    productStatus: optionalNonEmptyString(
+      statusFields.normalizedProductStatus
+    ),
+    status: optionalNonEmptyString(statusFields.normalizedSkuStatus),
+    cartActionDisabled: statusFields.cartActionDisabled,
+    customProductType,
+    slug,
+    productSlug: slug,
+    url: navigableUrl,
+    href: navigableUrl,
+    keywords: String(
+      productProperties["keyword"] ?? skuProperties["keyword"] ?? ""
+    ),
+    ingredientTerms: getIngredientTerms(
+      skuProperties["ingredients"] ?? productProperties["ingredients"]
+    )
+  };
+}
+function normalizeDidYouMean(didYouMean) {
+  if (!Array.isArray(didYouMean)) {
+    return [];
+  }
+  return didYouMean.map((item, index) => {
+    if (typeof item === "string") {
+      return {
+        id: `did-you-mean-${index}-${item}`,
+        value: item,
+        suggestionType: "did-you-mean"
+      };
+    }
+    if (item && typeof item === "object") {
+      const obj = item;
+      return {
+        ...obj,
+        id: String(
+          obj["id"] ?? `did-you-mean-${index}-${obj["value"] ?? obj["label"] ?? ""}`
+        ),
+        value: String(obj["value"] ?? ""),
+        suggestionType: "did-you-mean"
+      };
+    }
+    return null;
+  }).filter((item) => item !== null);
+}
+function getVisibleSuggestions(opts) {
+  if (opts.didYouMean.length > 0) {
+    return opts.didYouMean;
+  }
+  return opts.suggestions;
+}
+function getSeeMoreResultsPayload(query, totalResultsCount, suggestions) {
+  return {
+    query,
+    source: "autocomplete-footer",
+    totalResultsCount,
+    visibleResultsCount: suggestions.length
+  };
+}
+
+// src/hooks/useSearchSuggestions.ts
+function normalizeSuggestionsResponse(response) {
+  if (Array.isArray(response)) {
+    return {
+      suggestions: response,
+      didYouMean: []
+    };
+  }
+  if (!response || typeof response !== "object") {
+    return { suggestions: [], didYouMean: [] };
+  }
+  const r = response;
+  if (Array.isArray(r.product)) {
+    return {
+      suggestions: r.product.map(
+        (product, index) => mapCatalogProductToSuggestion(product, index)
+      ).filter((item) => item !== null),
+      didYouMean: normalizeDidYouMean(r.didYouMean ?? r.did_you_mean)
+    };
+  }
+  return {
+    suggestions: Array.isArray(r.suggestions) ? r.suggestions : [],
+    didYouMean: normalizeDidYouMean(r.didYouMean)
+  };
+}
+function useSearchSuggestions({
+  service,
+  enabled = true
+}) {
+  const [query, setQuery] = useState("");
+  const [suggestions, setSuggestions] = useState([]);
+  const [didYouMean, setDidYouMean] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [emptyFetched, setEmptyFetched] = useState(false);
+  const [hasMoreResults, setHasMoreResults] = useState(false);
+  const [totalResultsCount, setTotalResultsCount] = useState(0);
+  const fetchDebounced = useRef(null);
+  const latestRequestId = useRef(0);
+  const resetSuggestionsState = useCallback(() => {
+    setSuggestions([]);
+    setDidYouMean([]);
+    setEmptyFetched(false);
+    setHasMoreResults(false);
+    setTotalResultsCount(0);
+    setLoading(false);
+  }, []);
+  const updateQuery = useCallback(
+    (nextQuery) => {
+      const hasNextQuery = Boolean(nextQuery.trim());
+      setEmptyFetched(false);
+      setLoading(enabled && hasNextQuery);
+      setQuery(nextQuery);
+    },
+    [enabled]
+  );
+  const clearQuery = useCallback(() => {
+    resetSuggestionsState();
+    setQuery("");
+  }, [resetSuggestionsState]);
+  const runFetch = useCallback(
+    async (nextQuery) => {
+      const trimmedQuery = nextQuery.trim();
+      const requestId = latestRequestId.current;
+      if (!trimmedQuery || !enabled) {
+        resetSuggestionsState();
+        return;
+      }
+      setLoading(true);
+      setEmptyFetched(false);
+      try {
+        const fetchedSuggestions = await service.fetchSuggestions(trimmedQuery);
+        if (requestId !== latestRequestId.current) {
+          return;
+        }
+        const {
+          suggestions: allSuggestions,
+          didYouMean: suggestedTerms
+        } = normalizeSuggestionsResponse(fetchedSuggestions);
+        const visibleSuggestions = allSuggestions.slice(
+          0,
+          MAX_VISIBLE_SUGGESTIONS
+        );
+        const hasDidYouMean = suggestedTerms.length > 0;
+        const normalizedTotal = typeof fetchedSuggestions.totalResultsCount === "number" ? fetchedSuggestions.totalResultsCount : typeof fetchedSuggestions.pageableInfo?.totalCount === "number" ? fetchedSuggestions.pageableInfo.totalCount : allSuggestions.length;
+        const effectiveTotal = hasDidYouMean ? suggestedTerms.length : Math.max(normalizedTotal, allSuggestions.length);
+        setDidYouMean(suggestedTerms);
+        setSuggestions(hasDidYouMean ? [] : visibleSuggestions);
+        setHasMoreResults(
+          !hasDidYouMean && effectiveTotal > MAX_VISIBLE_SUGGESTIONS
+        );
+        setTotalResultsCount(effectiveTotal);
+        setEmptyFetched(
+          hasDidYouMean ? false : visibleSuggestions.length === 0 && suggestedTerms.length === 0
+        );
+      } catch {
+        if (requestId !== latestRequestId.current) {
+          return;
+        }
+        setSuggestions([]);
+        setDidYouMean([]);
+        setEmptyFetched(true);
+        setHasMoreResults(false);
+        setTotalResultsCount(0);
+      } finally {
+        if (requestId === latestRequestId.current) {
+          setLoading(false);
+        }
+      }
+    },
+    [enabled, service, resetSuggestionsState]
+  );
+  useEffect(() => {
+    if (!enabled) {
+      resetSuggestionsState();
+      return void 0;
+    }
+    if (fetchDebounced.current) {
+      clearTimeout(fetchDebounced.current);
+    }
+    latestRequestId.current += 1;
+    fetchDebounced.current = setTimeout(() => {
+      void runFetch(query);
+    }, DEBOUNCE_MS);
+    return () => {
+      if (fetchDebounced.current) {
+        clearTimeout(fetchDebounced.current);
+      }
+    };
+  }, [enabled, query, resetSuggestionsState, runFetch]);
+  return {
+    clearQuery,
+    emptyFetched,
+    hasMoreResults,
+    hasQuery: Boolean(query.trim()),
+    didYouMean,
+    loading,
+    query,
+    setQuery,
+    suggestions,
+    totalResultsCount,
+    updateQuery
+  };
+}
+
+// node_modules/zustand/esm/vanilla.mjs
+var createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const api = { setState, getState, getInitialState, subscribe };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+var identity = (arg) => arg;
+function useStore(api, selector = identity) {
+  const slice = React.useSyncExternalStore(
+    api.subscribe,
+    () => selector(api.getState()),
+    () => selector(api.getInitialState())
+  );
+  React.useDebugValue(slice);
+  return slice;
+}
+var createImpl = (createState) => {
+  const api = createStore(createState);
+  const useBoundStore = (selector) => useStore(api, selector);
+  Object.assign(useBoundStore, api);
+  return useBoundStore;
+};
+var create = (createState) => createImpl;
+
+// node_modules/zustand/esm/middleware.mjs
+function createJSONStorage(getStorage, options) {
+  let storage;
+  try {
+    storage = getStorage();
+  } catch (e) {
+    return;
+  }
+  const persistStorage = {
+    getItem: (name) => {
+      var _a;
+      const parse = (str2) => {
+        if (str2 === null) {
+          return null;
+        }
+        return JSON.parse(str2, void 0 );
+      };
+      const str = (_a = storage.getItem(name)) != null ? _a : null;
+      if (str instanceof Promise) {
+        return str.then(parse);
+      }
+      return parse(str);
+    },
+    setItem: (name, newValue) => storage.setItem(
+      name,
+      JSON.stringify(newValue, void 0 )
+    ),
+    removeItem: (name) => storage.removeItem(name)
+  };
+  return persistStorage;
+}
+var toThenable = (fn) => (input) => {
+  try {
+    const result = fn(input);
+    if (result instanceof Promise) {
+      return result;
+    }
+    return {
+      then(onFulfilled) {
+        return toThenable(onFulfilled)(result);
+      },
+      catch(_onRejected) {
+        return this;
+      }
+    };
+  } catch (e) {
+    return {
+      then(_onFulfilled) {
+        return this;
+      },
+      catch(onRejected) {
+        return toThenable(onRejected)(e);
+      }
+    };
+  }
+};
+var persistImpl = (config, baseOptions) => (set, get, api) => {
+  let options = {
+    storage: createJSONStorage(() => localStorage),
+    partialize: (state) => state,
+    version: 0,
+    merge: (persistedState, currentState) => ({
+      ...currentState,
+      ...persistedState
+    }),
+    ...baseOptions
+  };
+  let hasHydrated = false;
+  const hydrationListeners = /* @__PURE__ */ new Set();
+  const finishHydrationListeners = /* @__PURE__ */ new Set();
+  let storage = options.storage;
+  if (!storage) {
+    return config(
+      (...args) => {
+        console.warn(
+          `[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
+        );
+        set(...args);
+      },
+      get,
+      api
+    );
+  }
+  const setItem = () => {
+    const state = options.partialize({ ...get() });
+    return storage.setItem(options.name, {
+      state,
+      version: options.version
+    });
+  };
+  const savedSetState = api.setState;
+  api.setState = (state, replace) => {
+    savedSetState(state, replace);
+    void setItem();
+  };
+  const configResult = config(
+    (...args) => {
+      set(...args);
+      void setItem();
+    },
+    get,
+    api
+  );
+  api.getInitialState = () => configResult;
+  let stateFromStorage;
+  const hydrate = () => {
+    var _a, _b;
+    if (!storage) return;
+    hasHydrated = false;
+    hydrationListeners.forEach((cb) => {
+      var _a2;
+      return cb((_a2 = get()) != null ? _a2 : configResult);
+    });
+    const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? void 0 : _b.call(options, (_a = get()) != null ? _a : configResult)) || void 0;
+    return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => {
+      if (deserializedStorageValue) {
+        if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
+          if (options.migrate) {
+            return [
+              true,
+              options.migrate(
+                deserializedStorageValue.state,
+                deserializedStorageValue.version
+              )
+            ];
+          }
+          console.error(
+            `State loaded from storage couldn't be migrated since no migrate function was provided`
+          );
+        } else {
+          return [false, deserializedStorageValue.state];
+        }
+      }
+      return [false, void 0];
+    }).then((migrationResult) => {
+      var _a2;
+      const [migrated, migratedState] = migrationResult;
+      stateFromStorage = options.merge(
+        migratedState,
+        (_a2 = get()) != null ? _a2 : configResult
+      );
+      set(stateFromStorage, true);
+      if (migrated) {
+        return setItem();
+      }
+    }).then(() => {
+      postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
+      stateFromStorage = get();
+      hasHydrated = true;
+      finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
+    }).catch((e) => {
+      postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
+    });
+  };
+  api.persist = {
+    setOptions: (newOptions) => {
+      options = {
+        ...options,
+        ...newOptions
+      };
+      if (newOptions.storage) {
+        storage = newOptions.storage;
+      }
+    },
+    clearStorage: () => {
+      storage == null ? void 0 : storage.removeItem(options.name);
+    },
+    getOptions: () => options,
+    rehydrate: () => hydrate(),
+    hasHydrated: () => hasHydrated,
+    onHydrate: (cb) => {
+      hydrationListeners.add(cb);
+      return () => {
+        hydrationListeners.delete(cb);
+      };
+    },
+    onFinishHydration: (cb) => {
+      finishHydrationListeners.add(cb);
+      return () => {
+        finishHydrationListeners.delete(cb);
+      };
+    }
+  };
+  if (!options.skipHydration) {
+    hydrate();
+  }
+  return stateFromStorage || configResult;
+};
+var persist = persistImpl;
+
+// src/store/searchHistoryStore.ts
+var MAX_HISTORY = 10;
+var useSearchHistoryStore = create()(
+  persist(
+    (set) => ({
+      entries: [],
+      addEntry: (entry) => {
+        const trimmed = entry.query.trim();
+        if (!trimmed) return;
+        set((state) => {
+          const deduped = state.entries.filter(
+            (e) => e.query.toLowerCase() !== trimmed.toLowerCase()
+          );
+          const newEntry = {
+            ...entry,
+            query: trimmed,
+            timestamp: Date.now()
+          };
+          return {
+            entries: [newEntry, ...deduped].slice(0, MAX_HISTORY)
+          };
+        });
+      },
+      addQuery: (query) => {
+        const trimmed = query.trim();
+        if (!trimmed) return;
+        set((state) => {
+          const deduped = state.entries.filter(
+            (e) => e.query.toLowerCase() !== trimmed.toLowerCase()
+          );
+          return {
+            entries: [
+              {
+                query: trimmed,
+                isAI: false,
+                timestamp: Date.now()
+              },
+              ...deduped
+            ].slice(0, MAX_HISTORY)
+          };
+        });
+      },
+      removeEntry: (query) => set((state) => ({
+        entries: state.entries.filter((e) => e.query !== query)
+      })),
+      clearAll: () => set({ entries: [] })
+    }),
+    {
+      name: "ai_search_recent_queries",
+      version: 1,
+      storage: createJSONStorage(
+        () => typeof window !== "undefined" ? window.sessionStorage : {}
+      ),
+      // Migrate from v0 (queries: string[]) to v1 (entries: SearchHistoryEntry[])
+      migrate(persistedState, version) {
+        if (version === 0) {
+          const old = persistedState;
+          if (Array.isArray(old?.queries)) {
+            return {
+              entries: old.queries.map((q) => ({
+                query: q,
+                isAI: false,
+                timestamp: Date.now()
+              }))
+            };
+          }
+        }
+        return persistedState;
+      }
+    }
+  )
+);
+
+// src/hooks/useSearchHistory.ts
+function useSearchHistory() {
+  const entries = useSearchHistoryStore((s) => s.entries);
+  const addEntry = useSearchHistoryStore((s) => s.addEntry);
+  const addQuery = useSearchHistoryStore((s) => s.addQuery);
+  const removeEntry = useSearchHistoryStore((s) => s.removeEntry);
+  const clearAll = useSearchHistoryStore((s) => s.clearAll);
+  return {
+    entries,
+    queries: entries.map((e) => e.query),
+    addEntry,
+    addQuery,
+    removeEntry,
+    clearAll
+  };
+}
+function getSpeechRecognition() {
+  if (typeof window === "undefined") return null;
+  const w = window;
+  return w.SpeechRecognition ?? w.webkitSpeechRecognition ?? null;
+}
+function useVoiceSearch({
+  lang,
+  onResult,
+  onError
+}) {
+  const [listening, setListening] = useState(false);
+  const recognitionRef = useRef(null);
+  const supported = getSpeechRecognition() !== null;
+  const stop = useCallback(() => {
+    recognitionRef.current?.stop();
+    recognitionRef.current = null;
+    setListening(false);
+  }, []);
+  const start = useCallback(() => {
+    const SR = getSpeechRecognition();
+    if (!SR) return;
+    stop();
+    const rec = new SR();
+    rec.lang = lang ?? navigator.language ?? "en-US";
+    rec.interimResults = false;
+    rec.maxAlternatives = 1;
+    rec.onresult = (event) => {
+      const transcript = event.results[0]?.[0]?.transcript ?? "";
+      if (transcript) onResult(transcript);
+    };
+    rec.onerror = (event) => {
+      onError?.(event);
+      setListening(false);
+    };
+    rec.onend = () => setListening(false);
+    recognitionRef.current = rec;
+    rec.start();
+    setListening(true);
+  }, [lang, onResult, onError, stop]);
+  return { listening, supported, start, stop };
+}
+
+export { CATALOG_SUGGESTIONS_PATH, DEBOUNCE_MS, DEFAULT_AI_CHAT_BASE_URL, DEFAULT_AI_CHAT_CONVERSATIONS_URL, DEFAULT_AI_CHAT_MESSAGES_URL, DEFAULT_SEARCH_PATH, DEFAULT_SUGGESTION_PAGE, DEFAULT_SUGGESTION_SIZE, MAX_VISIBLE_SUGGESTIONS, RECENT_SEARCHES_DEFAULT_LIMIT, RECENT_SEARCHES_PREFIX, SEARCH_PLACEHOLDER, STOREFRONT_SHOPPING_CONTEXT, TRIGGER_PLACEHOLDER, createChatService, createSearchService, getImageFromProperty, getIngredientTerms, getSeeMoreResultsPayload, getVisibleSuggestions, isCartActionDisabled, isSellableProductStatus, isSuggestionDisabled, mapCatalogProductToSuggestion, normalizeDidYouMean, resolveApiGatewayPath, resolveSuggestionImageSrc, useSearchHistory, useSearchHistoryStore, useSearchSuggestions, useVoiceSearch };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map