@envive-ai/react-hooks 0.2.6-alpha-marlo.0 → 0.2.6-alpha-arthur-3

package/dist/search-CWkDtqQV.cjs

@@ -0,0 +1,312 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_dist = require('./dist-VxRI6eQv.cjs');
+const require_newOrgConfigAtom = require('./newOrgConfigAtom-CDttTiuu.cjs');
+const require_utils = require('./utils-CqVRbvfN.cjs');
+const require_searchServiceAdapter = require('./searchServiceAdapter-BclWy4fE.cjs');
+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_dist.ProductSorting.PRICE_ASC: return [...products].sort((p1, p2) => (p1.salePrice ?? p1.originalPrice ?? 0) - (p2.salePrice ?? p2.originalPrice ?? 0));
+			case require_dist.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/searchAPI.ts
+const searchAtom = (0, jotai.atom)({
+	data: null,
+	loading: false,
+	error: null,
+	lastQuery: null
+});
+const searchProductSortingAtom = (0, jotai.atom)(require_dist.ProductSorting.FEATURED);
+const searchSelectedFiltersAtom = (0, jotai.atom)([]);
+const createFilterOption = (filterId, filterItemId, displayName) => ({
+	id: `${filterId}:${filterItemId}`,
+	displayName,
+	filterId,
+	filterItemId
+});
+const internalSearchParamsAtom = (0, jotai.atom)({
+	id: null,
+	query: null
+});
+const searchParamsAtom = (0, jotai.atom)((get) => get(internalSearchParamsAtom), (_, set, value) => {
+	set(internalSearchParamsAtom, value);
+});
+const internalSearchSystemStateAtom = (0, jotai.atom)(false);
+const searchSystemAtom = (0, jotai.atom)((get) => get(internalSearchSystemStateAtom), (get, set, value) => {
+	if (value === get(internalSearchSystemStateAtom)) return;
+	const stateChangeHandler = () => {
+		const params = new URLSearchParams(window.location.search);
+		if (params.get("es") === "true") {
+			const id = params.get("esi");
+			const query = params.get("esq");
+			set(searchParamsAtom, {
+				id,
+				query
+			});
+		} else set(searchParamsAtom, {
+			id: null,
+			query: null
+		});
+	};
+	if (value) {
+		set(internalSearchSystemStateAtom, true);
+		window.addEventListener("popstate", stateChangeHandler);
+		stateChangeHandler();
+	} else {
+		set(internalSearchSystemStateAtom, false);
+		window.removeEventListener("popstate", stateChangeHandler);
+	}
+});
+const filteredSearchProductsAtom = (0, jotai.atom)((get) => {
+	const searchData = get(searchAtom).data;
+	const sorting = get(searchProductSortingAtom);
+	const selectedFilters = get(searchSelectedFiltersAtom);
+	const newOrgConfig = get(require_newOrgConfigAtom.newOrgConfigAtom);
+	if (!searchData?.products || !newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig) return [];
+	const filteredProducts = ProductFilters.filterProducts(searchData.products, newOrgConfig.frontendConfig.uiConfigs.searchConfig.searchFilterConfig, selectedFilters, newOrgConfig.frontendConfig.uiConfigs.searchConfig.additiveDynamicFilters);
+	return ProductSorter.sort(filteredProducts, sorting);
+});
+const searchFiltersAtom = (0, jotai.atom)((get) => {
+	const searchData = get(searchAtom).data;
+	const selectedFilters = get(searchSelectedFiltersAtom);
+	const newOrgConfig = get(require_newOrgConfigAtom.newOrgConfigAtom);
+	if (!searchData?.products || !newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig) return [];
+	return ProductFilters.getFiltersForProducts(searchData.products, newOrgConfig.frontendConfig.uiConfigs.searchConfig.searchFilterConfig, selectedFilters);
+});
+const addSearchFilterAtom = (0, jotai.atom)(null, (get, set, filter) => {
+	const current = get(searchSelectedFiltersAtom);
+	if (!current.some((f) => f.id === filter.id)) set(searchSelectedFiltersAtom, [...current, filter]);
+});
+const removeSearchFilterAtom = (0, jotai.atom)(null, (get, set, filterId) => {
+	const current = get(searchSelectedFiltersAtom);
+	set(searchSelectedFiltersAtom, current.filter((f) => f.id !== filterId));
+});
+const clearSearchFiltersAtom = (0, jotai.atom)(null, (_, set) => {
+	set(searchSelectedFiltersAtom, []);
+});
+const performSearchAtom = (0, jotai.atom)(null, async (get, set, params, allowRedirect = false) => {
+	const currentState = get(searchAtom);
+	const redirectSearchResultsUrl = get(require_newOrgConfigAtom.newOrgConfigAtom)?.frontendConfig?.uiConfigs?.searchConfig?.redirectSearchResultsUrl;
+	if (allowRedirect && redirectSearchResultsUrl) {
+		const redirectUrl = new URL(redirectSearchResultsUrl);
+		redirectUrl.searchParams.set("es", "true");
+		redirectUrl.searchParams.set("esq", params.query);
+		window.location.href = redirectUrl.toString();
+	} else {
+		const url = new URL(window.location.href);
+		url.searchParams.set("es", "true");
+		url.searchParams.set("esq", params.query);
+		window.history.pushState({}, "", url);
+		window.dispatchEvent(new PopStateEvent("popstate", { state: {} }));
+	}
+	window.dispatchEvent(new PopStateEvent("popstate", { state: {} }));
+	if (currentState.loading) return;
+	set(searchAtom, {
+		data: null,
+		loading: true,
+		error: null,
+		lastQuery: params.query
+	});
+	try {
+		const result = await require_searchServiceAdapter.getSearchServiceFunction()(params);
+		set(searchAtom, {
+			data: result,
+			loading: false,
+			error: null,
+			lastQuery: params.query
+		});
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "An unknown error occurred";
+		set(searchAtom, {
+			data: null,
+			loading: false,
+			error: errorMessage,
+			lastQuery: params.query
+		});
+	}
+});
+
+//#endregion
+Object.defineProperty(exports, 'addSearchFilterAtom', {
+  enumerable: true,
+  get: function () {
+    return addSearchFilterAtom;
+  }
+});
+Object.defineProperty(exports, 'clearSearchFiltersAtom', {
+  enumerable: true,
+  get: function () {
+    return clearSearchFiltersAtom;
+  }
+});
+Object.defineProperty(exports, 'createFilterOption', {
+  enumerable: true,
+  get: function () {
+    return createFilterOption;
+  }
+});
+Object.defineProperty(exports, 'filteredSearchProductsAtom', {
+  enumerable: true,
+  get: function () {
+    return filteredSearchProductsAtom;
+  }
+});
+Object.defineProperty(exports, 'internalSearchSystemStateAtom', {
+  enumerable: true,
+  get: function () {
+    return internalSearchSystemStateAtom;
+  }
+});
+Object.defineProperty(exports, 'performSearchAtom', {
+  enumerable: true,
+  get: function () {
+    return performSearchAtom;
+  }
+});
+Object.defineProperty(exports, 'removeSearchFilterAtom', {
+  enumerable: true,
+  get: function () {
+    return removeSearchFilterAtom;
+  }
+});
+Object.defineProperty(exports, 'searchAtom', {
+  enumerable: true,
+  get: function () {
+    return searchAtom;
+  }
+});
+Object.defineProperty(exports, 'searchFiltersAtom', {
+  enumerable: true,
+  get: function () {
+    return searchFiltersAtom;
+  }
+});
+Object.defineProperty(exports, 'searchParamsAtom', {
+  enumerable: true,
+  get: function () {
+    return searchParamsAtom;
+  }
+});
+Object.defineProperty(exports, 'searchProductSortingAtom', {
+  enumerable: true,
+  get: function () {
+    return searchProductSortingAtom;
+  }
+});
+Object.defineProperty(exports, 'searchSelectedFiltersAtom', {
+  enumerable: true,
+  get: function () {
+    return searchSelectedFiltersAtom;
+  }
+});
+Object.defineProperty(exports, 'searchSystemAtom', {
+  enumerable: true,
+  get: function () {
+    return searchSystemAtom;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"search-CWkDtqQV.cjs","names":["formatFilterDisplayName","ProductSorting","ProductSorting","newOrgConfigAtom","getSearchServiceFunction","error: unknown"],"sources":["../src/atoms/search/productFilters.ts","../src/atoms/search/productSorter.ts","../src/atoms/search/searchAPI.ts"],"sourcesContent":["import { ChatSearchFilter, ChatSearchFilterItem } from \"@envive-ai/types\";\nimport { FilterAttribute, ProductResponseAttributes } from \"src/types\";\nimport { SelectedFilterOption } from \"src/atoms/search/searchAPI\";\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 = (\n  a: ChatSearchFilterItem,\n  b: ChatSearchFilterItem\n) => 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}-$${\n                priceBucket + filterConfig.bucketSize\n              }`,\n              productCount: 0,\n            };\n            acc.map[priceBucket] = {\n              ...current,\n              productCount: current.productCount + 1,\n            };\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            [];\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] = {\n                ...current,\n                productCount: current.productCount + 1,\n              };\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(\n      ({ 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) =>\n                  option.id ===\n                  `${filterConfig.filterId}:${filter.filterItemId}`\n              ) ?? false,\n          }))\n          .sort(sortFilter(filterConfig)),\n      })\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 =\n                selectedFilter.filterConfig.attribute === \"dynamic\"; // True dynamic filters (the ones that appear beneath the search input)\n              const isSubtractiveLogic =\n                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(\n                  (selectedValue) =>\n                    attributeValues.some(\n                      (val) => val.toLowerCase() === selectedValue\n                    )\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 '@envive-ai/types';\nimport { ProductSorting } from '@envive-ai/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 { atom } from 'jotai';\nimport { ProductSorting } from '@envive-ai/types';\nimport { ProductFilters } from './productFilters';\nimport { ProductSorter } from './productSorter';\nimport { newOrgConfigAtom } from '../org';\nimport { getSearchServiceFunction } from './searchServiceAdapter';\nimport { SearchParams, SearchResult } from '@envive-ai/types';\n\nexport type SelectedFilterOption = {\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\ninterface SearchState {\n  data: SearchResult | null;\n  loading: boolean;\n  error: string | null;\n  lastQuery: string | null;\n}\n\nexport const searchAtom = atom<SearchState>({\n  data: null,\n  loading: false,\n  error: null,\n  lastQuery: null,\n});\n\nexport const searchProductSortingAtom = atom<ProductSorting>(ProductSorting.FEATURED);\nexport const searchSelectedFiltersAtom = atom<SelectedFilterOption[]>([]);\n\nexport const createFilterOption = (\n  filterId: string,\n  filterItemId: string,\n  displayName: string,\n): SelectedFilterOption => ({\n  id: `${filterId}:${filterItemId}`,\n  displayName,\n  filterId,\n  filterItemId,\n});\n\nconst internalSearchParamsAtom = atom<{\n  id: string | null;\n  query: string | null;\n}>({\n  id: null,\n  query: null,\n});\n\nexport const searchParamsAtom = atom(\n  (get) => get(internalSearchParamsAtom),\n  (_, set, value: { id: string | null; query: string | null }) => {\n    set(internalSearchParamsAtom, value);\n  },\n);\nexport const internalSearchSystemStateAtom = atom<boolean>(false);\n\nexport const searchSystemAtom = atom(\n  (get) => get(internalSearchSystemStateAtom),\n  (get, set, value: boolean) => {\n    if (value === get(internalSearchSystemStateAtom)) {\n      return;\n    }\n    const stateChangeHandler = () => {\n      const params = new URLSearchParams(window.location.search);\n      if (params.get('es') === 'true') {\n        const id = params.get('esi');\n        const query = params.get('esq');\n        set(searchParamsAtom, { id, query });\n      } else {\n        set(searchParamsAtom, { id: null, query: null });\n      }\n    };\n    if (value) {\n      set(internalSearchSystemStateAtom, true);\n      window.addEventListener('popstate', stateChangeHandler);\n      // Also trigger the hash change handler to set the initial state\n      stateChangeHandler();\n    } else {\n      set(internalSearchSystemStateAtom, false);\n      window.removeEventListener('popstate', stateChangeHandler);\n    }\n  },\n);\n\nexport const filteredSearchProductsAtom = atom((get) => {\n  const searchData = get(searchAtom).data;\n  const sorting = get(searchProductSortingAtom);\n  const selectedFilters = get(searchSelectedFiltersAtom);\n  const newOrgConfig = get(newOrgConfigAtom);\n\n  if (!searchData?.products || !newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig) return [];\n\n  const filteredProducts = ProductFilters.filterProducts(\n    searchData.products,\n    newOrgConfig.frontendConfig.uiConfigs.searchConfig.searchFilterConfig,\n    selectedFilters,\n    newOrgConfig.frontendConfig.uiConfigs.searchConfig.additiveDynamicFilters,\n  );\n\n  return ProductSorter.sort(filteredProducts, sorting);\n});\n\nexport const searchFiltersAtom = atom((get) => {\n  const searchData = get(searchAtom).data;\n  const selectedFilters = get(searchSelectedFiltersAtom);\n  const newOrgConfig = get(newOrgConfigAtom);\n\n  if (!searchData?.products || !newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig) return [];\n\n  return ProductFilters.getFiltersForProducts(\n    searchData.products,\n    newOrgConfig.frontendConfig.uiConfigs.searchConfig.searchFilterConfig,\n    selectedFilters,\n  );\n});\n\nexport const addSearchFilterAtom = atom(null, (get, set, filter: SelectedFilterOption) => {\n  const current = get(searchSelectedFiltersAtom);\n  if (!current.some((f) => f.id === filter.id)) {\n    set(searchSelectedFiltersAtom, [...current, filter]);\n  }\n});\n\nexport const removeSearchFilterAtom = atom(null, (get, set, filterId: string) => {\n  const current = get(searchSelectedFiltersAtom);\n  set(\n    searchSelectedFiltersAtom,\n    current.filter((f) => f.id !== filterId),\n  );\n});\n\nexport const clearSearchFiltersAtom = atom(null, (_, set) => {\n  set(searchSelectedFiltersAtom, []);\n});\n\nexport const performSearchAtom = atom(\n  null,\n  async (get, set, params: SearchParams, allowRedirect = false) => {\n    const currentState = get(searchAtom);\n    const newOrgConfig = get(newOrgConfigAtom);\n    const redirectSearchResultsUrl =\n      newOrgConfig?.frontendConfig?.uiConfigs?.searchConfig?.redirectSearchResultsUrl;\n\n    if (allowRedirect && redirectSearchResultsUrl) {\n      const redirectUrl = new URL(redirectSearchResultsUrl);\n      redirectUrl.searchParams.set('es', 'true');\n      redirectUrl.searchParams.set('esq', params.query);\n      window.location.href = redirectUrl.toString();\n    } else {\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', params.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\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    if (currentState.loading) {\n      return; // Prevent concurrent searches\n    }\n\n    set(searchAtom, {\n      data: null,\n      loading: true,\n      error: null,\n      lastQuery: params.query,\n    });\n    try {\n      const searchServiceFunction = getSearchServiceFunction();\n      const result = await searchServiceFunction(params);\n      set(searchAtom, {\n        data: result,\n        loading: false,\n        error: null,\n        lastQuery: params.query,\n      });\n    } catch (error: unknown) {\n      const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';\n      set(searchAtom, {\n        data: null,\n        loading: false,\n        error: errorMessage,\n        lastQuery: params.query,\n      });\n    }\n  },\n);\n"],"mappings":"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"}