@envive-ai/react-hooks 0.1.6 → 0.1.7

package/dist/chatSearch-B5jMnCYX.js

@@ -0,0 +1,315 @@
+import { MessageRole, MessageType } from "./models-Dn8Emdzc.js";
+import { messagesAtom, replyEventCategoryAtom, userHasRepliedAtom, userQueryAtom } from "./chatState-BrmBYY8l.js";
+import { queueUserEventAtom } from "./chat-DPJGdUkz.js";
+import { newOrgConfigAtom } from "./newOrgConfigAtom--tewb_G0.js";
+import { ProductSorting } from "./types-DIk0FLwd.js";
+import { UserEventCategory } from "@spiffy-ai/commerce-api-client";
+import { atom } from "jotai";
+import { v4 } from "uuid";
+
+//#region src/atoms/search/utils.ts
+const formatFilterDisplayName = (displayName) => {
+	const sizes = [
+		"xxxs",
+		"xxs",
+		"xs",
+		"s",
+		"m",
+		"l",
+		"xl",
+		"xxl",
+		"xxxl",
+		"xxxxl"
+	];
+	return displayName.toLowerCase().split(" ").map((word) => {
+		if (sizes.includes(word)) return word.toUpperCase();
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join(" ").replace(/Iphone/g, "iPhone");
+};
+
+//#endregion
+//#region src/atoms/search/productFilters.ts
+const getPriceBucket = (price, bucketSize) => {
+	return Math.floor(price / bucketSize) * bucketSize;
+};
+const isStringArray = (value) => {
+	if (!Array.isArray(value)) return false;
+	return value.every((item) => typeof item === "string");
+};
+const sortFilter = (filterConfig) => {
+	if (filterConfig.type === "price") return (a, b) => Number(a.filterItemId) - Number(b.filterItemId);
+	if (filterConfig.type === "dynamic") {
+		if (filterConfig.sorting.type === "alphabetic") return (a, b) => a.displayName.localeCompare(b.displayName);
+		if (filterConfig.sorting.type === "productCount") return (a, b) => a.productCount === b.productCount ? a.displayName.localeCompare(b.displayName) : b.productCount - a.productCount;
+		if (filterConfig.sorting.type === "custom") {
+			const sortedKeys = filterConfig.sorting.map;
+			return (a, b) => {
+				if (sortedKeys[a.displayName] && sortedKeys[b.displayName]) return sortedKeys[a.displayName] - sortedKeys[b.displayName];
+				if (sortedKeys[a.displayName]) return -1;
+				if (sortedKeys[b.displayName]) return 1;
+				return b.productCount - a.productCount;
+			};
+		}
+	}
+	throw new Error("Invaalid search filter configuration");
+};
+var ProductFilters = class {
+	static getFiltersForProducts(products, filterConfigs, selectedFilterOptions) {
+		if (!products || products.length === 0) return [];
+		return [...filterConfigs.map((filterConfig) => products.reduce((acc, product) => {
+			if (filterConfig.type === "price") {
+				const priceBucket = getPriceBucket(product.salePrice ?? product.originalPrice ?? 0, filterConfig.bucketSize);
+				const current = acc.map[priceBucket] ?? {
+					filterItemId: priceBucket,
+					displayName: `$${priceBucket}-$${priceBucket + filterConfig.bucketSize}`,
+					productCount: 0
+				};
+				acc.map[priceBucket] = {
+					...current,
+					productCount: current.productCount + 1
+				};
+				return acc;
+			}
+			const attributeValues = (product.filters && product.filters?.[filterConfig.attribute]) ?? [];
+			if (isStringArray(attributeValues)) attributeValues.forEach((val) => {
+				const normalizedVal = val.toLowerCase();
+				const current = acc.map[normalizedVal] ?? {
+					filterItemId: normalizedVal,
+					displayName: formatFilterDisplayName(val),
+					productCount: 0
+				};
+				acc.map[normalizedVal] = {
+					...current,
+					productCount: current.productCount + 1
+				};
+			});
+			return acc;
+		}, {
+			filterConfig,
+			map: {}
+		})).map(({ filterConfig, map }) => ({
+			filterId: filterConfig.filterId,
+			displayName: filterConfig.displayName,
+			items: Object.values(map).map((filter) => ({
+				filterItemId: filter.filterItemId,
+				displayName: filter.displayName,
+				productCount: filter.productCount,
+				isSelected: selectedFilterOptions.some((option) => option.id === `${filterConfig.filterId}:${filter.filterItemId}`) ?? false
+			})).sort(sortFilter(filterConfig))
+		}))];
+	}
+	static filterProducts(products, filterConfigs, selectedFilterOptions, additiveDynamicFilters = false) {
+		const selectedFilters = filterConfigs.map((filterConfig) => ({
+			filterConfig,
+			hasSelectedOptions: selectedFilterOptions.some((option) => option.filterId === filterConfig.filterId)
+		})).filter(({ hasSelectedOptions }) => hasSelectedOptions);
+		return selectedFilterOptions.length === 0 ? products : products.filter((product) => selectedFilters.reduce((acc, selectedFilter) => {
+			if (!acc) return acc;
+			if (selectedFilter.filterConfig.type === "price") {
+				const priceBucket = getPriceBucket(product.salePrice ?? product.originalPrice ?? 0, selectedFilter.filterConfig.bucketSize);
+				if (!selectedFilterOptions.some((option) => option.id === `price:${priceBucket}`)) return false;
+			}
+			if (selectedFilter.filterConfig.type === "dynamic") {
+				const { filterId, attribute } = selectedFilter.filterConfig;
+				const attributeValues = product.filters?.[attribute];
+				if (!isStringArray(attributeValues)) return false;
+				if (selectedFilter.filterConfig.attribute === "dynamic" && !additiveDynamicFilters) {
+					if (!selectedFilterOptions.filter((option) => option.filterId === filterId).map((option) => option.filterItemId.toLowerCase()).every((selectedValue) => attributeValues.some((val) => val.toLowerCase() === selectedValue))) return false;
+				} else if (!attributeValues.some((val) => selectedFilterOptions.some((option) => option.id === `${filterId}:${val.toLowerCase()}`))) return false;
+			}
+			return true;
+		}, true));
+	}
+};
+
+//#endregion
+//#region src/atoms/search/productSorter.ts
+var ProductSorter = class {
+	static sort(products, sorting) {
+		switch (sorting) {
+			case ProductSorting.PRICE_ASC: return [...products].sort((p1, p2) => (p1.salePrice ?? p1.originalPrice ?? 0) - (p2.salePrice ?? p2.originalPrice ?? 0));
+			case ProductSorting.PRICE_DESC: return [...products].sort((p1, p2) => (p2.salePrice ?? p2.originalPrice ?? 0) - (p1.salePrice ?? p1.originalPrice ?? 0));
+			default: return products;
+		}
+	}
+};
+
+//#endregion
+//#region src/atoms/search/chatSearch.ts
+const chatSearchStateAtom = atom("entrypoint");
+const chatSearchHasProductsAtom = atom(false);
+const chatSearchProductSortingAtom = atom(ProductSorting.FEATURED);
+const filterProductList = (message) => message.type === MessageType.Product && message.metadata.isForGrid === true;
+const filterFilterList = (message) => message.type === MessageType.ProductSearchFilter;
+const chatSearchIsLoadingAtom = atom(false);
+const buildChatSearchTurn = (messages) => {
+	const queryMessage = messages.find((message) => message.type === MessageType.ProductSearch);
+	if (!queryMessage) return null;
+	const { generatedQuery, productCount } = queryMessage.metadata ?? {};
+	const productList = messages.filter(filterProductList).map((message) => message.metadata);
+	const filterList = messages.filter(filterFilterList).map((message) => message.metadata.filterName);
+	return [queryMessage.id, {
+		id: queryMessage.id,
+		generatedQuery,
+		productCount: productCount || productList.length,
+		productList,
+		filterList,
+		messages
+	}];
+};
+const chatSearchFilterConfigAtom = atom((get) => {
+	return get(newOrgConfigAtom)?.frontendConfig?.uiConfigs?.searchConfig?.searchFilterConfig || [];
+});
+const searchMapAtom = atom((get) => {
+	const messages = get(messagesAtom);
+	return Object.fromEntries(messages.map(buildChatSearchTurn).filter((v) => v !== null));
+});
+const internalChatSearchParamsAtom = atom({
+	id: null,
+	query: null
+});
+const selectedFilterOptionsAtom = atom([]);
+const additiveDynamicFiltersAtom = atom((get) => {
+	return get(newOrgConfigAtom)?.frontendConfig?.uiConfigs?.searchConfig?.additiveDynamicFilters ?? false;
+});
+const createChatSearchFilterOption = (filterId, filterItemId, displayName) => ({
+	id: `${filterId}:${filterItemId}`,
+	displayName,
+	filterId,
+	filterItemId
+});
+const handleSearchAtom = atom(null, (get, set, message) => {
+	if (message.type !== MessageType.Search) return;
+	const querySearch = message.metadata.searchTerm;
+	set(replyEventCategoryAtom, UserEventCategory.Search);
+	set(userQueryAtom, querySearch);
+	set(messagesAtom, [...get(messagesAtom), [message]]);
+	set(userHasRepliedAtom, true);
+	set(queueUserEventAtom, {
+		eventId: message.id,
+		category: UserEventCategory.Search,
+		createdAt: message.createdAt,
+		attributes: {
+			searchTerm: message.metadata.searchTerm,
+			selectedFilters: message.metadata.selectedFilters
+		}
+	});
+});
+const chatSearchParamsAtom = atom((get) => get(internalChatSearchParamsAtom), (_, set, value) => {
+	set(internalChatSearchParamsAtom, value);
+});
+const chatSearchQueryAtom = atom((get) => get(chatSearchParamsAtom)?.query ?? null, (get, set, value) => {
+	const searchParams = get(chatSearchParamsAtom);
+	set(chatSearchParamsAtom, {
+		id: searchParams.id,
+		query: value
+	});
+});
+const chatSearchIdAtom = atom((get) => get(chatSearchParamsAtom)?.id ?? null, (get, set, value) => {
+	const searchParams = get(chatSearchParamsAtom);
+	set(chatSearchParamsAtom, {
+		id: value,
+		query: searchParams.query
+	});
+});
+const ChatSearchTurnAtom = atom((get) => {
+	const searchFilterConfig = get(chatSearchFilterConfigAtom);
+	const searchMap = get(searchMapAtom);
+	const chatSearchId = get(chatSearchIdAtom);
+	if (!chatSearchId) return null;
+	const ChatSearchTurn = searchMap[chatSearchId];
+	if (!ChatSearchTurn) return null;
+	const productSorting = get(chatSearchProductSortingAtom);
+	const selectedFilterOptions = get(selectedFilterOptionsAtom);
+	const additiveDynamicFilters = get(additiveDynamicFiltersAtom);
+	const filteredProducts = ProductFilters.filterProducts(ChatSearchTurn.productList, searchFilterConfig, selectedFilterOptions, additiveDynamicFilters);
+	const filteredAndSortedProducts = ProductSorter.sort(filteredProducts, productSorting);
+	return {
+		...searchMap[chatSearchId],
+		productList: filteredAndSortedProducts,
+		productCount: filteredAndSortedProducts.length
+	};
+});
+const chatSearchProducts = atom((get) => {
+	return get(ChatSearchTurnAtom)?.productList ?? [];
+});
+const chatSearchFiltersAtom = atom((get) => {
+	const searchFilterConfig = get(chatSearchFilterConfigAtom);
+	const searchMap = get(searchMapAtom);
+	const chatSearchId = get(chatSearchIdAtom);
+	if (chatSearchId && searchMap[chatSearchId]) {
+		const products = searchMap[chatSearchId].productList;
+		const selectedFilterOptions = get(selectedFilterOptionsAtom);
+		return ProductFilters.getFiltersForProducts(products, searchFilterConfig, selectedFilterOptions);
+	}
+	return [];
+});
+const setSearchParams = (query) => {
+	const url = new URL(window.location.href);
+	url.searchParams.set("es", "true");
+	url.searchParams.set("esq", query);
+	window.history.pushState({}, "", url);
+};
+const getSearchParamsAtom = atom(() => {
+	const params = new URLSearchParams(window.location.search);
+	return {
+		es: params.get("es"),
+		esq: params.get("esq")
+	};
+});
+const initiateChatSearchAtom = atom(null, (_, set, query) => {
+	set(chatSearchIsLoadingAtom, true);
+	const url = new URL(window.location.href);
+	url.searchParams.set("es", "true");
+	url.searchParams.set("esq", query);
+	window.history.pushState({}, "", url);
+	window.dispatchEvent(new PopStateEvent("popstate", { state: {} }));
+	set(chatSearchParamsAtom, {
+		id: null,
+		query
+	});
+	set(handleSearchAtom, {
+		id: v4(),
+		role: MessageRole.User,
+		type: MessageType.Search,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		metadata: {
+			searchTerm: query,
+			selectedFilters: []
+		}
+	});
+});
+const handleSearchResultsAtom = atom(null, (get, set, message) => {
+	if (!message || message.type !== MessageType.ProductSearch) return;
+	const { productCount, generatedQuery } = message.metadata;
+	if (productCount !== 0) {
+		set(selectedFilterOptionsAtom, []);
+		set(chatSearchStateAtom, "product-page");
+		const currentSearchParams = get(chatSearchParamsAtom);
+		const url = new URL(window.location.href);
+		url.searchParams.set("es", "true");
+		url.searchParams.set("esq", generatedQuery);
+		url.searchParams.set("esi", message.id);
+		window.history.pushState({}, "", url);
+		if (currentSearchParams.id === null) window.history.replaceState(null, "", url);
+		else window.history.pushState(null, "", url);
+		set(chatSearchParamsAtom, {
+			id: message.id,
+			query: generatedQuery
+		});
+	}
+});
+const setChatSearchParamsAtom = atom(null, (_, set, query) => {
+	const url = new URL(window.location.href);
+	url.searchParams.set("es", "true");
+	url.searchParams.set("esq", query);
+	window.history.pushState({}, "", url);
+	set(chatSearchParamsAtom, {
+		id: null,
+		query
+	});
+});
+
+//#endregion
+export { ChatSearchTurnAtom, ProductFilters, ProductSorter, additiveDynamicFiltersAtom, chatSearchFiltersAtom, chatSearchHasProductsAtom, chatSearchIdAtom, chatSearchIsLoadingAtom, chatSearchParamsAtom, chatSearchProductSortingAtom, chatSearchProducts, chatSearchQueryAtom, chatSearchStateAtom, createChatSearchFilterOption, formatFilterDisplayName, getSearchParamsAtom, handleSearchResultsAtom, initiateChatSearchAtom, selectedFilterOptionsAtom, setChatSearchParamsAtom, setSearchParams };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"chatSearch-B5jMnCYX.js","names":["uuid"],"sources":["../src/atoms/search/utils.ts","../src/atoms/search/productFilters.ts","../src/atoms/search/productSorter.ts","../src/atoms/search/chatSearch.ts"],"sourcesContent":["export const formatFilterDisplayName = (displayName: string) => {\n  const sizes = ['xxxs', 'xxs', 'xs', 's', 'm', 'l', 'xl', 'xxl', 'xxxl', 'xxxxl'];\n\n  const processedWords = displayName\n    .toLowerCase()\n    .split(' ')\n    .map((word) => {\n      if (sizes.includes(word)) {\n        return word.toUpperCase();\n      }\n      return word.charAt(0).toUpperCase() + word.slice(1);\n    });\n\n  const titleCasedName = processedWords.join(' ');\n\n  // Final replacements for special cases\n  return titleCasedName.replace(/Iphone/g, 'iPhone');\n};\n","import { ProductResponseAttributes } from 'src/application/models';\nimport { FilterAttribute } from 'src/contexts/types';\nimport { SelectedFilterOption } from 'src/atoms/search/searchAPI';\nimport { ChatSearchFilter, ChatSearchFilterItem } from './types';\nimport { formatFilterDisplayName } from './utils';\n\nconst getPriceBucket = (price: number, bucketSize: number) => {\n  const bucket = Math.floor(price / bucketSize);\n  return bucket * bucketSize;\n};\n\nconst isStringArray = (value: unknown): value is string[] => {\n  if (!Array.isArray(value)) {\n    return false;\n  }\n  return value.every((item) => typeof item === 'string');\n};\n\ntype FilterSortFunction = (a: ChatSearchFilterItem, b: ChatSearchFilterItem) => number;\n\nconst sortFilter = (filterConfig: FilterAttribute): FilterSortFunction => {\n  if (filterConfig.type === 'price') {\n    return (a, b) => Number(a.filterItemId) - Number(b.filterItemId);\n  }\n  if (filterConfig.type === 'dynamic') {\n    if (filterConfig.sorting.type === 'alphabetic') {\n      return (a, b) => a.displayName.localeCompare(b.displayName);\n    }\n    // Sort by the number of products, if they match, sort by alphabetical\n    if (filterConfig.sorting.type === 'productCount') {\n      return (a, b) =>\n        a.productCount === b.productCount\n          ? a.displayName.localeCompare(b.displayName)\n          : b.productCount - a.productCount;\n    }\n    if (filterConfig.sorting.type === 'custom') {\n      const sortedKeys = filterConfig.sorting.map;\n      return (a, b) => {\n        if (sortedKeys[a.displayName] && sortedKeys[b.displayName]) {\n          // If both are in the sortedKeys, sort by the index\n          return sortedKeys[a.displayName] - sortedKeys[b.displayName];\n        }\n        // If only 'a' is in the sortedKeys, put it before the other\n        if (sortedKeys[a.displayName]) {\n          return -1;\n        }\n        // If only 'b' is in the sortedKeys, put it before the other\n        if (sortedKeys[b.displayName]) {\n          return 1;\n        }\n        // If neither are in the sortedKeys, sort by productCount\n        return b.productCount - a.productCount;\n      };\n    }\n  }\n  throw new Error('Invaalid search filter configuration');\n};\n\nexport class ProductFilters {\n  static getFiltersForProducts(\n    products: ProductResponseAttributes['attributes'][],\n    filterConfigs: FilterAttribute[],\n    selectedFilterOptions: SelectedFilterOption[],\n  ): ChatSearchFilter[] {\n    if (!products || products.length === 0) {\n      return [];\n    }\n\n    const filters = filterConfigs.map((filterConfig) =>\n      products.reduce(\n        (acc, product) => {\n          // Price has special handling for the filters\n          if (filterConfig.type === 'price') {\n            const priceBucket = getPriceBucket(\n              product.salePrice ?? product.originalPrice ?? 0,\n              filterConfig.bucketSize,\n            );\n            const current = acc.map[priceBucket] ?? {\n              filterItemId: priceBucket,\n              displayName: `$${priceBucket}-$${priceBucket + filterConfig.bucketSize}`,\n              productCount: 0,\n            };\n            acc.map[priceBucket] = { ...current, productCount: current.productCount + 1 };\n            return acc;\n          }\n\n          // Assume that the \"attribute\" is an array of values\n          const attributeValues =\n            (product.filters && product.filters?.[filterConfig.attribute]) ?? [];\n          if (isStringArray(attributeValues)) {\n            attributeValues.forEach((val) => {\n              const normalizedVal = val.toLowerCase();\n              const current = acc.map[normalizedVal] ?? {\n                filterItemId: normalizedVal,\n                displayName: formatFilterDisplayName(val), // Keep original case for display\n                productCount: 0,\n              };\n              acc.map[normalizedVal] = { ...current, productCount: current.productCount + 1 };\n            });\n          }\n\n          return acc;\n        },\n        {\n          filterConfig,\n          map: {} as Record<string, ChatSearchFilterItem>,\n        },\n      ),\n    );\n\n    const transformedFilters: ChatSearchFilter[] = filters.map(({ filterConfig, map }) => ({\n      filterId: filterConfig.filterId,\n      displayName: filterConfig.displayName,\n      items: Object.values(map)\n        .map((filter) => ({\n          filterItemId: filter.filterItemId,\n          displayName: filter.displayName,\n          productCount: filter.productCount,\n          isSelected:\n            selectedFilterOptions.some(\n              (option) => option.id === `${filterConfig.filterId}:${filter.filterItemId}`,\n            ) ?? false,\n        }))\n        .sort(sortFilter(filterConfig)),\n    }));\n\n    return [...transformedFilters];\n  }\n\n  static filterProducts(\n    products: ProductResponseAttributes['attributes'][],\n    filterConfigs: FilterAttribute[],\n    selectedFilterOptions: SelectedFilterOption[],\n    additiveDynamicFilters = false, // Set this to true to restore the original behavior where stacking filters has OR logic.\n  ) {\n    const selectedFilters = filterConfigs\n      .map((filterConfig) => ({\n        filterConfig,\n        hasSelectedOptions: selectedFilterOptions.some(\n          (option) => option.filterId === filterConfig.filterId,\n        ),\n      }))\n      .filter(({ hasSelectedOptions }) => hasSelectedOptions);\n    return selectedFilterOptions.length === 0\n      ? products\n      : products.filter((product) =>\n          selectedFilters.reduce((acc, selectedFilter) => {\n            // Finding one false removes the product\n            if (!acc) {\n              return acc;\n            }\n            // Price is special\n            if (selectedFilter.filterConfig.type === 'price') {\n              const priceBucket = getPriceBucket(\n                product.salePrice ?? product.originalPrice ?? 0,\n                selectedFilter.filterConfig.bucketSize,\n              );\n              const matchesPriceFilter = selectedFilterOptions.some(\n                (option) => option.id === `price:${priceBucket}`,\n              );\n              if (!matchesPriceFilter) {\n                return false;\n              }\n            }\n\n            if (selectedFilter.filterConfig.type === 'dynamic') {\n              // dynamic is misleading here. Its not just dynamic filters, but static filters because the config counts static filters as type: dynamic.\n              const { filterId, attribute } = selectedFilter.filterConfig;\n              const attributeValues = product.filters?.[attribute];\n\n              if (!isStringArray(attributeValues)) {\n                return false;\n              }\n\n              const isDynamicFilter = selectedFilter.filterConfig.attribute === 'dynamic'; // True dynamic filters (the ones that appear beneath the search input)\n              const isSubtractiveLogic = isDynamicFilter && !additiveDynamicFilters;\n\n              if (isSubtractiveLogic) {\n                // AND logic for subtractive dynamic filters and between static filter categories\n                const selectedOptionsForThisFilter = selectedFilterOptions\n                  .filter((option) => option.filterId === filterId)\n                  .map((option) => option.filterItemId.toLowerCase());\n\n                const hasAllSelectedValues = selectedOptionsForThisFilter.every((selectedValue) =>\n                  attributeValues.some((val) => val.toLowerCase() === selectedValue),\n                );\n\n                if (!hasAllSelectedValues) {\n                  return false;\n                }\n              } else {\n                // OR logic for static filters in the sidebar within a category.\n                const matches = attributeValues.some((val) =>\n                  selectedFilterOptions.some(\n                    (option) => option.id === `${filterId}:${val.toLowerCase()}`,\n                  ),\n                );\n                if (!matches) {\n                  return false;\n                }\n              }\n            }\n            return true;\n          }, true),\n        );\n  }\n}\n","import { ProductResponseAttributes } from 'src/application/models';\nimport { ProductSorting } from './types';\n\nexport class ProductSorter {\n  static sort(products: ProductResponseAttributes['attributes'][], sorting: ProductSorting) {\n    switch (sorting) {\n      case ProductSorting.PRICE_ASC:\n        return [...products].sort(\n          (p1, p2) =>\n            (p1.salePrice ?? p1.originalPrice ?? 0) - (p2.salePrice ?? p2.originalPrice ?? 0),\n        );\n\n      case ProductSorting.PRICE_DESC:\n        return [...products].sort(\n          (p1, p2) =>\n            (p2.salePrice ?? p2.originalPrice ?? 0) - (p1.salePrice ?? p1.originalPrice ?? 0),\n        );\n\n      default:\n        return products;\n    }\n  }\n}\n","import { UserEventCategory } from \"@spiffy-ai/commerce-api-client\";\nimport { v4 as uuid } from \"uuid\";\nimport { atom } from \"jotai\";\nimport {\n  Message,\n  MessageRole,\n  MessageType,\n  ProductResponseAttributes,\n} from \"src/application/models\";\nimport {\n  messagesAtom,\n  replyEventCategoryAtom,\n  userHasRepliedAtom,\n  userQueryAtom,\n} from \"src/atoms/chat\";\nimport { queueUserEventAtom } from \"../chat/messageQueue\";\nimport { newOrgConfigAtom } from \"../org\";\nimport { ProductFilters } from \"./productFilters\";\nimport { ProductSorter } from \"./productSorter\";\nimport { ChatSearchStateType, ProductSorting } from \"./types\";\n\n// NOTE:\n// This is a legacy version of search that needs to be decoupled and removed.\n// the new search.ts file in this directory is likely what you're looking for.\n\nexport const chatSearchStateAtom = atom<ChatSearchStateType>(\"entrypoint\");\nexport const chatSearchHasProductsAtom = atom<boolean>(false);\nexport const chatSearchProductSortingAtom = atom<ProductSorting>(\n  ProductSorting.FEATURED\n);\n\nconst filterProductList = (message: Message) =>\n  message.type === MessageType.Product && message.metadata.isForGrid === true;\nconst filterFilterList = (message: Message) =>\n  message.type === MessageType.ProductSearchFilter;\n\nexport type ChatSearchTurn = {\n  id: string;\n  generatedQuery?: string;\n  productCount: number;\n  productList: ProductResponseAttributes[\"attributes\"][];\n  filterList: string[];\n  messages: Message[];\n};\n\nexport const chatSearchIsLoadingAtom = atom(false);\n\nconst buildChatSearchTurn = (\n  messages: Message[]\n): [string, ChatSearchTurn] | null => {\n  const queryMessage = messages.find(\n    (message) => message.type === MessageType.ProductSearch\n  );\n  if (!queryMessage) {\n    return null;\n  }\n  const { generatedQuery, productCount } = queryMessage.metadata ?? {};\n  const productList = messages\n    .filter(filterProductList)\n    .map((message) => (message as any).metadata);\n  const filterList = messages\n    .filter(filterFilterList)\n    .map((message) => message.metadata.filterName);\n  return [\n    queryMessage.id,\n    {\n      id: queryMessage.id,\n      generatedQuery,\n      productCount: productCount || productList.length,\n      productList,\n      filterList,\n      messages,\n    },\n  ];\n};\n\nconst chatSearchFilterConfigAtom = atom((get) => {\n  const newOrgConfig = get(newOrgConfigAtom);\n  return (\n    newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig?.searchFilterConfig ||\n    []\n  );\n});\n\nconst searchMapAtom = atom((get) => {\n  const messages = get(messagesAtom);\n  return Object.fromEntries(\n    messages.map(buildChatSearchTurn).filter((v) => v !== null)\n  );\n});\n\nconst internalChatSearchParamsAtom = atom<{\n  id: string | null;\n  query: string | null;\n}>({\n  id: null,\n  query: null,\n});\n\n// Selected filter options with compound objects for better type safety and display\nexport type SelectedChatSearchFilterOption = {\n  id: string; // \"filterId:filterItemId\" - maintains backward compatibility for comparisons\n  displayName: string;\n  filterId: string; // Filter category\n  filterItemId: string; // Filter value\n};\n\nexport const selectedFilterOptionsAtom = atom<SelectedChatSearchFilterOption[]>(\n  []\n);\n\nexport const additiveDynamicFiltersAtom = atom((get) => {\n  const newOrgConfig = get(newOrgConfigAtom);\n  return (\n    newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig\n      ?.additiveDynamicFilters ?? false\n  );\n});\n\nexport const createChatSearchFilterOption = (\n  filterId: string,\n  filterItemId: string,\n  displayName: string\n): SelectedChatSearchFilterOption => ({\n  id: `${filterId}:${filterItemId}`,\n  displayName,\n  filterId,\n  filterItemId,\n});\n\nconst handleSearchAtom = atom(null, (get, set, message: Message) => {\n  if (message.type !== MessageType.Search) {\n    return;\n  }\n\n  const querySearch = message.metadata.searchTerm;\n\n  set(replyEventCategoryAtom, UserEventCategory.Search);\n  set(userQueryAtom, querySearch);\n  set(messagesAtom, [...get(messagesAtom), [message]]);\n  set(userHasRepliedAtom, true);\n\n  set(queueUserEventAtom, {\n    eventId: message.id,\n    category: UserEventCategory.Search,\n    createdAt: message.createdAt,\n    attributes: {\n      searchTerm: message.metadata.searchTerm,\n      selectedFilters: message.metadata.selectedFilters,\n    },\n  });\n});\n\n// This internal atom is used to store the search params\nexport const chatSearchParamsAtom = atom(\n  (get) => get(internalChatSearchParamsAtom),\n  (_, set, value: { id: string | null; query: string | null }) => {\n    set(internalChatSearchParamsAtom, value);\n  }\n);\n\nexport const chatSearchQueryAtom = atom(\n  (get) => get(chatSearchParamsAtom)?.query ?? null,\n  (get, set, value: string | null) => {\n    const searchParams = get(chatSearchParamsAtom);\n    set(chatSearchParamsAtom, { id: searchParams.id, query: value });\n  }\n);\n\nexport const chatSearchIdAtom = atom(\n  (get) => get(chatSearchParamsAtom)?.id ?? null,\n  (get, set, value: string | null) => {\n    const searchParams = get(chatSearchParamsAtom);\n    set(chatSearchParamsAtom, { id: value, query: searchParams.query });\n  }\n);\n\nexport const ChatSearchTurnAtom = atom((get) => {\n  const searchFilterConfig = get(chatSearchFilterConfigAtom);\n  const searchMap = get(searchMapAtom);\n  const chatSearchId = get(chatSearchIdAtom);\n  if (!chatSearchId) {\n    return null;\n  }\n  const ChatSearchTurn = searchMap[chatSearchId];\n  if (!ChatSearchTurn) {\n    return null;\n  }\n  const productSorting = get(chatSearchProductSortingAtom);\n  const selectedFilterOptions = get(selectedFilterOptionsAtom);\n  const additiveDynamicFilters = get(additiveDynamicFiltersAtom);\n  const filteredProducts = ProductFilters.filterProducts(\n    ChatSearchTurn.productList,\n    searchFilterConfig,\n    selectedFilterOptions,\n    additiveDynamicFilters\n  );\n\n  const filteredAndSortedProducts = ProductSorter.sort(\n    filteredProducts,\n    productSorting\n  );\n\n  return {\n    ...searchMap[chatSearchId],\n    productList: filteredAndSortedProducts,\n    productCount: filteredAndSortedProducts.length,\n  };\n});\n\n// TODO: Work on deprecating this atom in favor of using ChatSearchTurnAtom directly\nexport const chatSearchProducts = atom((get) => {\n  const ChatSearchTurn = get(ChatSearchTurnAtom);\n  return ChatSearchTurn?.productList ?? [];\n});\n\nexport const chatSearchFiltersAtom = atom((get) => {\n  const searchFilterConfig = get(chatSearchFilterConfigAtom);\n  const searchMap = get(searchMapAtom);\n  const chatSearchId = get(chatSearchIdAtom);\n\n  if (chatSearchId && searchMap[chatSearchId]) {\n    const products = searchMap[chatSearchId].productList;\n    const selectedFilterOptions = get(selectedFilterOptionsAtom);\n    return ProductFilters.getFiltersForProducts(\n      products,\n      searchFilterConfig,\n      selectedFilterOptions\n    );\n  }\n  return [];\n});\n\n// For search we use the following query params:\n// es: true - this indicates that we are in a search state\n// esq: query - this is the current search query\n// esi: search id - this is the unique id for the search results that we are displaying. It is pulled from the message id from the turn that includes the search results\n\nexport const setSearchParams = (query: string) => {\n  const url = new URL(window.location.href);\n  url.searchParams.set(\"es\", \"true\");\n  url.searchParams.set(\"esq\", query);\n  window.history.pushState({}, \"\", url);\n};\n\nexport const getSearchParamsAtom = atom(() => {\n  const params = new URLSearchParams(window.location.search);\n  return {\n    es: params.get(\"es\"),\n    esq: params.get(\"esq\"),\n  };\n});\n\nexport const initiateChatSearchAtom = atom(null, (_, set, query: string) => {\n  set(chatSearchIsLoadingAtom, true);\n  // Update URL and manually trigger state change (since pushState doesn't trigger popstate)\n  const url = new URL(window.location.href);\n  url.searchParams.set(\"es\", \"true\");\n  url.searchParams.set(\"esq\", query);\n  window.history.pushState({}, \"\", url);\n\n  // Manually trigger page variant re-evaluation by dispatching a popstate event\n  // This ensures the page variant system detects the URL change and mounts search results\n  window.dispatchEvent(new PopStateEvent(\"popstate\", { state: {} }));\n\n  set(chatSearchParamsAtom, { id: null, query });\n  set(handleSearchAtom, {\n    id: uuid(),\n    role: MessageRole.User,\n    type: MessageType.Search,\n    createdAt: new Date().toISOString(),\n    metadata: {\n      searchTerm: query,\n      // Enabling this will enable the new backend search\n      selectedFilters: [],\n    },\n  });\n});\n\nexport const handleSearchResultsAtom = atom(\n  null,\n  (get, set, message: Message | undefined) => {\n    if (!message || message.type !== MessageType.ProductSearch) {\n      return;\n    }\n\n    const { productCount, generatedQuery } = message.metadata;\n    if (productCount !== 0) {\n      // Clear the filter options when we get new products\n      set(selectedFilterOptionsAtom, []);\n      // TODO: Should we still do any of these things?\n      set(chatSearchStateAtom, \"product-page\");\n      const currentSearchParams = get(chatSearchParamsAtom);\n      const url = new URL(window.location.href);\n      url.searchParams.set(\"es\", \"true\");\n      url.searchParams.set(\"esq\", generatedQuery);\n      url.searchParams.set(\"esi\", message.id);\n      window.history.pushState({}, \"\", url);\n      if (currentSearchParams.id === null) {\n        // If the id is null, we need to replace the state\n        window.history.replaceState(null, \"\", url);\n      } else {\n        // If the query is different, we need to push a new state\n        window.history.pushState(null, \"\", url);\n      }\n      set(chatSearchParamsAtom, { id: message.id, query: generatedQuery });\n    }\n  }\n);\n\nexport const setChatSearchParamsAtom = atom(null, (_, set, query: string) => {\n  const url = new URL(window.location.href);\n  url.searchParams.set(\"es\", \"true\");\n  url.searchParams.set(\"esq\", query);\n  window.history.pushState({}, \"\", url);\n  set(chatSearchParamsAtom, { id: null, query });\n});\n"],"mappings":"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"}