@envive-ai/react-hooks 0.2.6-alpha-arthur-2 → 0.2.6-alpha.11

package/dist/chatSearch-DpnpRWAW.cjs

@@ -0,0 +1,418 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_models = require('./models-D-4db7XW.cjs');
+const require_chatState = require('./chatState-CcFtSqJT.cjs');
+const require_chat = require('./chat-CqPuT9_V.cjs');
+const require_newOrgConfigAtom = require('./newOrgConfigAtom-D6R-7HCk.cjs');
+const require_utils = require('./utils-2SWrJ12w.cjs');
+const require_types = require('./types-CxObxLKs.cjs');
+let __spiffy_ai_commerce_api_client = require("@spiffy-ai/commerce-api-client");
+__spiffy_ai_commerce_api_client = require_chunk.__toESM(__spiffy_ai_commerce_api_client);
+let uuid = require("uuid");
+uuid = require_chunk.__toESM(uuid);
+let jotai = require("jotai");
+jotai = require_chunk.__toESM(jotai);
+
+//#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: require_utils.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 require_types.ProductSorting.PRICE_ASC: return [...products].sort((p1, p2) => (p1.salePrice ?? p1.originalPrice ?? 0) - (p2.salePrice ?? p2.originalPrice ?? 0));
+			case require_types.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 = (0, jotai.atom)("entrypoint");
+const chatSearchHasProductsAtom = (0, jotai.atom)(false);
+const chatSearchProductSortingAtom = (0, jotai.atom)(require_types.ProductSorting.FEATURED);
+const filterProductList = (message) => message.type === require_models.MessageType.Product && message.metadata.isForGrid === true;
+const filterFilterList = (message) => message.type === require_models.MessageType.ProductSearchFilter;
+const chatSearchIsLoadingAtom = (0, jotai.atom)(false);
+const buildChatSearchTurn = (messages) => {
+	const queryMessage = messages.find((message) => message.type === require_models.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 = (0, jotai.atom)((get) => {
+	return get(require_newOrgConfigAtom.newOrgConfigAtom)?.frontendConfig?.uiConfigs?.searchConfig?.searchFilterConfig || [];
+});
+const searchMapAtom = (0, jotai.atom)((get) => {
+	const messages = get(require_chatState.messagesAtom);
+	return Object.fromEntries(messages.map(buildChatSearchTurn).filter((v) => v !== null));
+});
+const internalChatSearchParamsAtom = (0, jotai.atom)({
+	id: null,
+	query: null
+});
+const selectedFilterOptionsAtom = (0, jotai.atom)([]);
+const additiveDynamicFiltersAtom = (0, jotai.atom)((get) => {
+	return get(require_newOrgConfigAtom.newOrgConfigAtom)?.frontendConfig?.uiConfigs?.searchConfig?.additiveDynamicFilters ?? false;
+});
+const createChatSearchFilterOption = (filterId, filterItemId, displayName) => ({
+	id: `${filterId}:${filterItemId}`,
+	displayName,
+	filterId,
+	filterItemId
+});
+const handleSearchAtom = (0, jotai.atom)(null, (get, set, message) => {
+	if (message.type !== require_models.MessageType.Search) return;
+	const querySearch = message.metadata.searchTerm;
+	set(require_chatState.replyEventCategoryAtom, __spiffy_ai_commerce_api_client.UserEventCategory.Search);
+	set(require_chatState.userQueryAtom, querySearch);
+	set(require_chatState.messagesAtom, [...get(require_chatState.messagesAtom), [message]]);
+	set(require_chatState.userHasRepliedAtom, true);
+	set(require_chat.queueUserEventAtom, {
+		eventId: message.id,
+		category: __spiffy_ai_commerce_api_client.UserEventCategory.Search,
+		createdAt: message.createdAt,
+		attributes: {
+			searchTerm: message.metadata.searchTerm,
+			selectedFilters: message.metadata.selectedFilters
+		}
+	});
+});
+const chatSearchParamsAtom = (0, jotai.atom)((get) => get(internalChatSearchParamsAtom), (_, set, value) => {
+	set(internalChatSearchParamsAtom, value);
+});
+const chatSearchQueryAtom = (0, jotai.atom)((get) => get(chatSearchParamsAtom)?.query ?? null, (get, set, value) => {
+	const searchParams = get(chatSearchParamsAtom);
+	set(chatSearchParamsAtom, {
+		id: searchParams.id,
+		query: value
+	});
+});
+const chatSearchIdAtom = (0, jotai.atom)((get) => get(chatSearchParamsAtom)?.id ?? null, (get, set, value) => {
+	const searchParams = get(chatSearchParamsAtom);
+	set(chatSearchParamsAtom, {
+		id: value,
+		query: searchParams.query
+	});
+});
+const ChatSearchTurnAtom = (0, jotai.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 = (0, jotai.atom)((get) => {
+	return get(ChatSearchTurnAtom)?.productList ?? [];
+});
+const chatSearchFiltersAtom = (0, jotai.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 = (0, jotai.atom)(() => {
+	const params = new URLSearchParams(window.location.search);
+	return {
+		es: params.get("es"),
+		esq: params.get("esq")
+	};
+});
+const initiateChatSearchAtom = (0, jotai.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: (0, uuid.v4)(),
+		role: require_models.MessageRole.User,
+		type: require_models.MessageType.Search,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		metadata: {
+			searchTerm: query,
+			selectedFilters: []
+		}
+	});
+});
+const handleSearchResultsAtom = (0, jotai.atom)(null, (get, set, message) => {
+	if (!message || message.type !== require_models.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 = (0, jotai.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
+Object.defineProperty(exports, 'ChatSearchTurnAtom', {
+  enumerable: true,
+  get: function () {
+    return ChatSearchTurnAtom;
+  }
+});
+Object.defineProperty(exports, 'ProductFilters', {
+  enumerable: true,
+  get: function () {
+    return ProductFilters;
+  }
+});
+Object.defineProperty(exports, 'ProductSorter', {
+  enumerable: true,
+  get: function () {
+    return ProductSorter;
+  }
+});
+Object.defineProperty(exports, 'additiveDynamicFiltersAtom', {
+  enumerable: true,
+  get: function () {
+    return additiveDynamicFiltersAtom;
+  }
+});
+Object.defineProperty(exports, 'chatSearchFiltersAtom', {
+  enumerable: true,
+  get: function () {
+    return chatSearchFiltersAtom;
+  }
+});
+Object.defineProperty(exports, 'chatSearchHasProductsAtom', {
+  enumerable: true,
+  get: function () {
+    return chatSearchHasProductsAtom;
+  }
+});
+Object.defineProperty(exports, 'chatSearchIdAtom', {
+  enumerable: true,
+  get: function () {
+    return chatSearchIdAtom;
+  }
+});
+Object.defineProperty(exports, 'chatSearchIsLoadingAtom', {
+  enumerable: true,
+  get: function () {
+    return chatSearchIsLoadingAtom;
+  }
+});
+Object.defineProperty(exports, 'chatSearchParamsAtom', {
+  enumerable: true,
+  get: function () {
+    return chatSearchParamsAtom;
+  }
+});
+Object.defineProperty(exports, 'chatSearchProductSortingAtom', {
+  enumerable: true,
+  get: function () {
+    return chatSearchProductSortingAtom;
+  }
+});
+Object.defineProperty(exports, 'chatSearchProducts', {
+  enumerable: true,
+  get: function () {
+    return chatSearchProducts;
+  }
+});
+Object.defineProperty(exports, 'chatSearchQueryAtom', {
+  enumerable: true,
+  get: function () {
+    return chatSearchQueryAtom;
+  }
+});
+Object.defineProperty(exports, 'chatSearchStateAtom', {
+  enumerable: true,
+  get: function () {
+    return chatSearchStateAtom;
+  }
+});
+Object.defineProperty(exports, 'createChatSearchFilterOption', {
+  enumerable: true,
+  get: function () {
+    return createChatSearchFilterOption;
+  }
+});
+Object.defineProperty(exports, 'getSearchParamsAtom', {
+  enumerable: true,
+  get: function () {
+    return getSearchParamsAtom;
+  }
+});
+Object.defineProperty(exports, 'handleSearchResultsAtom', {
+  enumerable: true,
+  get: function () {
+    return handleSearchResultsAtom;
+  }
+});
+Object.defineProperty(exports, 'initiateChatSearchAtom', {
+  enumerable: true,
+  get: function () {
+    return initiateChatSearchAtom;
+  }
+});
+Object.defineProperty(exports, 'selectedFilterOptionsAtom', {
+  enumerable: true,
+  get: function () {
+    return selectedFilterOptionsAtom;
+  }
+});
+Object.defineProperty(exports, 'setChatSearchParamsAtom', {
+  enumerable: true,
+  get: function () {
+    return setChatSearchParamsAtom;
+  }
+});
+Object.defineProperty(exports, 'setSearchParams', {
+  enumerable: true,
+  get: function () {
+    return setSearchParams;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"chatSearch-DpnpRWAW.cjs","names":["formatFilterDisplayName","ProductSorting","ProductSorting","MessageType","newOrgConfigAtom","messagesAtom","replyEventCategoryAtom","UserEventCategory","userQueryAtom","userHasRepliedAtom","queueUserEventAtom","MessageRole"],"sources":["../src/atoms/search/productFilters.ts","../src/atoms/search/productSorter.ts","../src/atoms/search/chatSearch.ts"],"sourcesContent":["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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"}

package/dist/chatState-CcFtSqJT.cjs

@@ -0,0 +1,120 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_models = require('./models-D-4db7XW.cjs');
+const require_utils = require('./utils-CLGXsOwE.cjs');
+let jotai = require("jotai");
+jotai = require_chunk.__toESM(jotai);
+let __spiffy_ai_commerce_api_client_dist_models_UserEventCategory = require("@spiffy-ai/commerce-api-client/dist/models/UserEventCategory");
+__spiffy_ai_commerce_api_client_dist_models_UserEventCategory = require_chunk.__toESM(__spiffy_ai_commerce_api_client_dist_models_UserEventCategory);
+
+//#region src/atoms/chat/chatState.ts
+const userHasRepliedAtom = (0, jotai.atom)(false);
+const replyEventCategoryAtom = (0, jotai.atom)(__spiffy_ai_commerce_api_client_dist_models_UserEventCategory.UserEventCategory.AppLoaded);
+const userQueryAtom = (0, jotai.atom)();
+const suggestionAtom = (0, jotai.atom)(void 0);
+const askQuestionBtnClickedAtom = (0, jotai.atom)(false);
+const messagesAtom = (0, jotai.atom)([]);
+const userEventsAtom = (0, jotai.atom)([]);
+const suggestionsAtom = (0, jotai.atom)([]);
+const suggestionsLoadingAtom = (0, jotai.atom)(false);
+const responseStreamingAtom = (0, jotai.atom)(false);
+const chatIsOpenAtom = (0, jotai.atom)(false);
+const requestFailureAtom = (0, jotai.atom)(false);
+const formSubmitAtom = (0, jotai.atom)();
+const chatOnToggleAtom = (0, jotai.atom)(null, (get, set, triggerLocation, track) => {
+	const isOpen = get(chatIsOpenAtom);
+	set(chatIsOpenAtom, !isOpen);
+	if (!isOpen) {
+		window.dispatchEvent(new CustomEvent(require_models.SpiffyEventName.WidgetOpen));
+		track?.(require_utils.SpiffyMetricsEventName.ChatComponentExpanded, { message_metadata: { trigger_location: triggerLocation } });
+	} else {
+		window.dispatchEvent(new CustomEvent(require_models.SpiffyEventName.WidgetClose));
+		track?.(require_utils.SpiffyMetricsEventName.ChatComponentCollapsed);
+	}
+});
+
+//#endregion
+Object.defineProperty(exports, 'askQuestionBtnClickedAtom', {
+  enumerable: true,
+  get: function () {
+    return askQuestionBtnClickedAtom;
+  }
+});
+Object.defineProperty(exports, 'chatIsOpenAtom', {
+  enumerable: true,
+  get: function () {
+    return chatIsOpenAtom;
+  }
+});
+Object.defineProperty(exports, 'chatOnToggleAtom', {
+  enumerable: true,
+  get: function () {
+    return chatOnToggleAtom;
+  }
+});
+Object.defineProperty(exports, 'formSubmitAtom', {
+  enumerable: true,
+  get: function () {
+    return formSubmitAtom;
+  }
+});
+Object.defineProperty(exports, 'messagesAtom', {
+  enumerable: true,
+  get: function () {
+    return messagesAtom;
+  }
+});
+Object.defineProperty(exports, 'replyEventCategoryAtom', {
+  enumerable: true,
+  get: function () {
+    return replyEventCategoryAtom;
+  }
+});
+Object.defineProperty(exports, 'requestFailureAtom', {
+  enumerable: true,
+  get: function () {
+    return requestFailureAtom;
+  }
+});
+Object.defineProperty(exports, 'responseStreamingAtom', {
+  enumerable: true,
+  get: function () {
+    return responseStreamingAtom;
+  }
+});
+Object.defineProperty(exports, 'suggestionAtom', {
+  enumerable: true,
+  get: function () {
+    return suggestionAtom;
+  }
+});
+Object.defineProperty(exports, 'suggestionsAtom', {
+  enumerable: true,
+  get: function () {
+    return suggestionsAtom;
+  }
+});
+Object.defineProperty(exports, 'suggestionsLoadingAtom', {
+  enumerable: true,
+  get: function () {
+    return suggestionsLoadingAtom;
+  }
+});
+Object.defineProperty(exports, 'userEventsAtom', {
+  enumerable: true,
+  get: function () {
+    return userEventsAtom;
+  }
+});
+Object.defineProperty(exports, 'userHasRepliedAtom', {
+  enumerable: true,
+  get: function () {
+    return userHasRepliedAtom;
+  }
+});
+Object.defineProperty(exports, 'userQueryAtom', {
+  enumerable: true,
+  get: function () {
+    return userQueryAtom;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/chatState-DKnNHmwe.js

@@ -0,0 +1,34 @@
+import { SpiffyEventName } from "./models-c86hYW-F.js";
+import { SpiffyMetricsEventName } from "./utils-jYtD3hmA.js";
+import { atom } from "jotai";
+import { UserEventCategory } from "@spiffy-ai/commerce-api-client/dist/models/UserEventCategory";
+
+//#region src/atoms/chat/chatState.ts
+const userHasRepliedAtom = atom(false);
+const replyEventCategoryAtom = atom(UserEventCategory.AppLoaded);
+const userQueryAtom = atom();
+const suggestionAtom = atom(void 0);
+const askQuestionBtnClickedAtom = atom(false);
+const messagesAtom = atom([]);
+const userEventsAtom = atom([]);
+const suggestionsAtom = atom([]);
+const suggestionsLoadingAtom = atom(false);
+const responseStreamingAtom = atom(false);
+const chatIsOpenAtom = atom(false);
+const requestFailureAtom = atom(false);
+const formSubmitAtom = atom();
+const chatOnToggleAtom = atom(null, (get, set, triggerLocation, track) => {
+	const isOpen = get(chatIsOpenAtom);
+	set(chatIsOpenAtom, !isOpen);
+	if (!isOpen) {
+		window.dispatchEvent(new CustomEvent(SpiffyEventName.WidgetOpen));
+		track?.(SpiffyMetricsEventName.ChatComponentExpanded, { message_metadata: { trigger_location: triggerLocation } });
+	} else {
+		window.dispatchEvent(new CustomEvent(SpiffyEventName.WidgetClose));
+		track?.(SpiffyMetricsEventName.ChatComponentCollapsed);
+	}
+});
+
+//#endregion
+export { askQuestionBtnClickedAtom, chatIsOpenAtom, chatOnToggleAtom, formSubmitAtom, messagesAtom, replyEventCategoryAtom, requestFailureAtom, responseStreamingAtom, suggestionAtom, suggestionsAtom, suggestionsLoadingAtom, userEventsAtom, userHasRepliedAtom, userQueryAtom };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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