@wix/headless-stores 0.0.41 → 0.0.43

package/dist/services/products-list-search-service.js

@@ -0,0 +1,813 @@
+import { defineService, implementService } from "@wix/services-definitions";
+import { SignalsServiceDefinition } from "@wix/services-definitions/core-services/signals";
+import { DEFAULT_QUERY_LIMIT, ProductsListServiceDefinition, } from "./products-list-service.js";
+import { productsV3, customizationsV3 } from "@wix/stores";
+import { loadCategoriesListServiceConfig } from "./categories-list-service.js";
+const PRICE_FILTER_DEBOUNCE_TIME = 300;
+import { SortType } from "./../enums/sort-enums.js";
+export { SortType } from "./../enums/sort-enums.js";
+/**
+ * Enumeration of inventory status types available for filtering.
+ * Re-exports the Wix inventory availability status enum values.
+ */
+export const InventoryStatusType = productsV3.InventoryAvailabilityStatus;
+/**
+ * Service definition for the Products List Search service.
+ * This consolidates sort, pagination, and filtering functionality.
+ */
+export const ProductsListSearchServiceDefinition = defineService("products-list-search");
+/**
+ * Convert SortType enum to URL format
+ */
+function convertSortTypeToUrl(sortType) {
+    switch (sortType) {
+        case SortType.NAME_ASC:
+            return "name";
+        case SortType.NAME_DESC:
+            return "name:desc";
+        case SortType.PRICE_ASC:
+            return "price";
+        case SortType.PRICE_DESC:
+            return "price:desc";
+        case SortType.NEWEST:
+            return "newest";
+        case SortType.RECOMMENDED:
+            return "recommended";
+        default:
+            return "name";
+    }
+}
+/**
+ * Convert URL sort format to SortType enum
+ */
+export function convertUrlSortToSortType(urlSort) {
+    const sortParts = urlSort.split(":");
+    const field = sortParts[0]?.toLowerCase();
+    const order = sortParts[1]?.toLowerCase() === "desc" ? "desc" : "asc";
+    switch (field) {
+        case "name":
+            return order === "desc" ? SortType.NAME_DESC : SortType.NAME_ASC;
+        case "price":
+            return order === "desc" ? SortType.PRICE_DESC : SortType.PRICE_ASC;
+        case "newest":
+        case "created":
+            return SortType.NEWEST;
+        case "recommended":
+            return SortType.RECOMMENDED;
+        default:
+            return null;
+    }
+}
+/**
+ * Update URL with current search state (sort, filters, pagination)
+ */
+function updateUrlWithSearchState(searchState) {
+    if (typeof window === "undefined")
+        return;
+    const { sort, filters, customizations, catalogBounds, categorySlug } = searchState;
+    // Convert filter IDs back to human-readable names for URL
+    const humanReadableOptions = {};
+    for (const [optionId, choiceIds] of Object.entries(filters?.productOptions ?? {})) {
+        const option = customizations.find((c) => c._id === optionId);
+        if (option && option.name) {
+            const choiceNames = [];
+            for (const choiceId of choiceIds) {
+                const choice = option.choicesSettings?.choices?.find((c) => c._id === choiceId);
+                if (choice && choice.name) {
+                    choiceNames.push(choice.name);
+                }
+            }
+            if (choiceNames.length > 0) {
+                humanReadableOptions[option.name] = choiceNames;
+            }
+        }
+    }
+    // Start with current URL parameters to preserve non-search parameters
+    const params = new URLSearchParams(window.location.search);
+    // Define search-related parameters that we manage
+    const searchParams = [
+        "sort",
+        "limit",
+        "cursor",
+        "minPrice",
+        "maxPrice",
+        "inventoryStatus",
+        "visible",
+        "productType",
+        // Product option names will be dynamically added below
+        // Note: category is NOT included here as it's handled in the URL path
+    ];
+    // Remove existing search parameters first
+    searchParams.forEach((param) => params.delete(param));
+    // Remove existing product option parameters (they have dynamic names)
+    for (const customization of customizations) {
+        if (customization.customizationType ===
+            customizationsV3.CustomizationType.PRODUCT_OPTION &&
+            customization.name) {
+            params.delete(customization.name);
+        }
+    }
+    // Add sort parameter (only if not default)
+    const urlSort = convertSortTypeToUrl(sort);
+    if (sort !== SortType.NAME_ASC) {
+        params.set("sort", urlSort);
+    }
+    // Add price range parameters only if they differ from catalog bounds
+    if (filters.priceRange?.min &&
+        filters.priceRange.min > catalogBounds.minPrice) {
+        params.set("minPrice", filters.priceRange.min.toString());
+    }
+    if (filters.priceRange?.max &&
+        filters.priceRange.max < catalogBounds.maxPrice) {
+        params.set("maxPrice", filters.priceRange.max.toString());
+    }
+    // Add inventory status parameters
+    if (filters.inventoryStatuses && filters.inventoryStatuses.length > 0) {
+        params.set("inventoryStatus", filters.inventoryStatuses.join(","));
+    }
+    // Add visibility filter (only if explicitly false, since true is default)
+    if (filters.visible === false) {
+        params.set("visible", "false");
+    }
+    // Add product type filter
+    if (filters.productType) {
+        params.set("productType", filters.productType);
+    }
+    // Add product options as individual parameters (Color=Red,Blue&Size=Large)
+    for (const [optionName, values] of Object.entries(humanReadableOptions)) {
+        if (values.length > 0) {
+            params.set(optionName, values.join(","));
+        }
+    }
+    // Handle URL path construction with category
+    let baseUrl = window.location.pathname;
+    // If categorySlug is provided, update the path
+    if (categorySlug) {
+        if (categorySlug) {
+            baseUrl = `/category/${categorySlug}`;
+        }
+    }
+    // Build the new URL
+    const newUrl = params.toString()
+        ? `${baseUrl}?${params.toString()}`
+        : baseUrl;
+    // Only update if URL actually changed
+    if (newUrl !== window.location.pathname + window.location.search) {
+        window.history.pushState(null, "", newUrl);
+    }
+}
+/**
+ * Parse URL and build complete search options with all filters, sort, and pagination
+ */
+export async function parseUrlForProductsListSearch(url, categoriesList, defaultSearchOptions) {
+    const urlObj = new URL(url);
+    const searchParams = urlObj.searchParams;
+    // Get customizations for product option parsing
+    const { items: customizations = [] } = await customizationsV3
+        .queryCustomizations()
+        .find();
+    // Build search options
+    const searchOptions = {
+        cursorPaging: {
+            limit: DEFAULT_QUERY_LIMIT,
+        },
+        ...defaultSearchOptions,
+    };
+    // Initialize search state for service
+    const initialSearchState = {};
+    // Extract category slug from URL path (e.g., /category/category-slug)
+    const pathSegments = urlObj.pathname.split("/");
+    const categoryIndex = pathSegments.findIndex((segment) => segment === "category");
+    let categorySlug = null;
+    let category = undefined;
+    if (categoryIndex !== -1 && categoryIndex + 1 < pathSegments.length) {
+        categorySlug = pathSegments[categoryIndex + 1] || null;
+        // Find the category by slug from the provided categories list
+        if (categorySlug) {
+            category = categoriesList.find((cat) => cat.slug === categorySlug);
+            if (category) {
+                initialSearchState.category = category;
+            }
+        }
+    }
+    // Handle text search (q parameter)
+    const query = searchParams.get("q");
+    if (query) {
+        searchOptions.search = {
+            expression: query,
+        };
+    }
+    // Handle sorting
+    const sort = searchParams.get("sort");
+    if (sort) {
+        const sortType = convertUrlSortToSortType(sort);
+        if (sortType) {
+            initialSearchState.sort = sortType;
+            // Apply sort to search options
+            switch (sortType) {
+                case SortType.NAME_ASC:
+                    searchOptions.sort = [
+                        { fieldName: "name", order: productsV3.SortDirection.ASC },
+                    ];
+                    break;
+                case SortType.NAME_DESC:
+                    searchOptions.sort = [
+                        { fieldName: "name", order: productsV3.SortDirection.DESC },
+                    ];
+                    break;
+                case SortType.PRICE_ASC:
+                    searchOptions.sort = [
+                        {
+                            fieldName: "actualPriceRange.minValue.amount",
+                            order: productsV3.SortDirection.ASC,
+                        },
+                    ];
+                    break;
+                case SortType.PRICE_DESC:
+                    searchOptions.sort = [
+                        {
+                            fieldName: "actualPriceRange.minValue.amount",
+                            order: productsV3.SortDirection.DESC,
+                        },
+                    ];
+                    break;
+                case SortType.RECOMMENDED:
+                    searchOptions.sort = [
+                        {
+                            fieldName: "name",
+                            order: productsV3.SortDirection.DESC,
+                        },
+                    ];
+                    break;
+            }
+        }
+    }
+    // Handle pagination
+    const limit = searchParams.get("limit");
+    const cursor = searchParams.get("cursor");
+    if (limit || cursor) {
+        searchOptions.cursorPaging = {};
+        if (limit) {
+            const limitNum = parseInt(limit, 10);
+            if (!isNaN(limitNum) && limitNum > 0) {
+                searchOptions.cursorPaging.limit = limitNum;
+                initialSearchState.limit = limitNum;
+            }
+        }
+        if (cursor) {
+            searchOptions.cursorPaging.cursor = cursor;
+            initialSearchState.cursor = cursor;
+        }
+    }
+    // Handle filtering for search options
+    const filter = {};
+    const visible = searchParams.get("visible");
+    if (visible !== null) {
+        filter["visible"] = visible === "true";
+        initialSearchState.visible = visible === "true";
+    }
+    const productType = searchParams.get("productType");
+    if (productType) {
+        filter["productType"] = productType;
+        initialSearchState.productType = productType;
+    }
+    // Add category filter if found
+    if (category) {
+        filter["allCategoriesInfo.categories"] = {
+            $matchItems: [{ _id: { $in: [category._id] } }],
+        };
+    }
+    // Price range filtering
+    const minPrice = searchParams.get("minPrice");
+    const maxPrice = searchParams.get("maxPrice");
+    if (minPrice || maxPrice) {
+        initialSearchState.priceRange = {};
+        if (minPrice) {
+            const minPriceNum = parseFloat(minPrice);
+            if (!isNaN(minPriceNum)) {
+                filter["actualPriceRange.minValue.amount"] = { $gte: minPriceNum };
+                initialSearchState.priceRange.min = minPriceNum;
+            }
+        }
+        if (maxPrice) {
+            const maxPriceNum = parseFloat(maxPrice);
+            if (!isNaN(maxPriceNum)) {
+                filter["actualPriceRange.maxValue.amount"] = { $lte: maxPriceNum };
+                initialSearchState.priceRange.max = maxPriceNum;
+            }
+        }
+    }
+    // Parse product options from URL parameters
+    const reservedParams = [
+        "minPrice",
+        "maxPrice",
+        "inventory_status",
+        "inventoryStatus",
+        "visible",
+        "productType",
+        "q",
+        "limit",
+        "cursor",
+        "sort",
+    ];
+    const productOptionsById = {};
+    for (const [optionName, optionValues] of searchParams.entries()) {
+        if (reservedParams.includes(optionName))
+            continue;
+        // Find the option by name in customizations
+        const option = customizations.find((c) => c.name === optionName &&
+            c.customizationType ===
+                customizationsV3.CustomizationType.PRODUCT_OPTION);
+        if (option && option._id) {
+            const choiceValues = optionValues.split(",").filter(Boolean);
+            const choiceIds = [];
+            // Convert choice names to IDs
+            for (const choiceName of choiceValues) {
+                const choice = option.choicesSettings?.choices?.find((c) => c.name === choiceName);
+                if (choice && choice._id) {
+                    choiceIds.push(choice._id);
+                }
+            }
+            if (choiceIds.length > 0) {
+                productOptionsById[option._id] = choiceIds;
+                // Add product option filter to search options
+                filter[`options.choicesSettings.choices.choiceId`] = {
+                    $hasSome: choiceIds,
+                };
+            }
+        }
+    }
+    if (Object.keys(productOptionsById).length > 0) {
+        initialSearchState.productOptions = productOptionsById;
+    }
+    // Add filter to search options if any filters were set
+    if (Object.keys(filter).length > 0) {
+        searchOptions.filter = filter;
+    }
+    // Add aggregations for getting filter options
+    searchOptions.aggregations = [
+        {
+            name: "minPrice",
+            fieldPath: "actualPriceRange.minValue.amount",
+            type: "SCALAR",
+            scalar: { type: "MIN" },
+        },
+        {
+            name: "maxPrice",
+            fieldPath: "actualPriceRange.maxValue.amount",
+            type: "SCALAR",
+            scalar: { type: "MAX" },
+        },
+        {
+            name: "optionNames",
+            fieldPath: "options.name",
+            type: productsV3.SortType.VALUE,
+            value: {
+                limit: 20,
+                sortType: productsV3.SortType.VALUE,
+                sortDirection: productsV3.SortDirection.ASC,
+            },
+        },
+        {
+            name: "choiceNames",
+            fieldPath: "options.choicesSettings.choices.name",
+            type: productsV3.SortType.VALUE,
+            value: {
+                limit: 50,
+                sortType: productsV3.SortType.VALUE,
+                sortDirection: productsV3.SortDirection.ASC,
+            },
+        },
+        {
+            name: "inventoryStatus",
+            fieldPath: "inventory.availabilityStatus",
+            type: productsV3.SortType.VALUE,
+            value: {
+                limit: 10,
+                sortType: productsV3.SortType.VALUE,
+                sortDirection: productsV3.SortDirection.ASC,
+            },
+        },
+    ];
+    return { searchOptions, initialSearchState };
+}
+/**
+ * Load search service configuration from URL
+ */
+export async function loadProductsListSearchServiceConfig(url) {
+    // Load categories using the categories service
+    const categoriesListConfig = await loadCategoriesListServiceConfig();
+    const { initialSearchState } = await parseUrlForProductsListSearch(url, categoriesListConfig.categories);
+    const { items: customizations = [] } = await customizationsV3
+        .queryCustomizations()
+        .find();
+    return {
+        customizations,
+        initialSearchState,
+    };
+}
+/**
+ * Implementation of the Products List Search service
+ */
+export const ProductsListSearchService = implementService.withConfig()(ProductsListSearchServiceDefinition, ({ getService, config }) => {
+    let firstRun = true;
+    const signalsService = getService(SignalsServiceDefinition);
+    const productsListService = getService(ProductsListServiceDefinition);
+    const { customizations, initialSearchState } = config;
+    const aggregationData = productsListService.aggregations.get()?.results;
+    const currentSearchOptions = productsListService.searchOptions.get();
+    // Sort signals
+    const selectedSortOptionSignal = signalsService.signal(initialSearchState?.sort || SortType.NAME_ASC);
+    // Pagination signals
+    const currentLimitSignal = signalsService.signal(initialSearchState?.limit || getCurrentLimit(currentSearchOptions));
+    const currentCursorSignal = signalsService.signal(initialSearchState?.cursor || getCurrentCursor(currentSearchOptions));
+    // Filter signals
+    const catalogPriceRange = getCatalogPriceRange(aggregationData || []);
+    const userFilterMinPriceSignal = signalsService.signal(initialSearchState?.priceRange?.min ?? catalogPriceRange.minPrice);
+    const userFilterMaxPriceSignal = signalsService.signal(initialSearchState?.priceRange?.max ?? catalogPriceRange.maxPrice);
+    const catalogMinPriceSignal = signalsService.signal(catalogPriceRange.minPrice);
+    const catalogMaxPriceSignal = signalsService.signal(catalogPriceRange.maxPrice);
+    const availableInventoryStatusesSignal = signalsService.signal([
+        InventoryStatusType.IN_STOCK,
+        InventoryStatusType.OUT_OF_STOCK,
+        InventoryStatusType.PARTIALLY_OUT_OF_STOCK,
+    ]);
+    const selectedInventoryStatusesSignal = signalsService.signal(initialSearchState?.inventoryStatuses || []);
+    const availableProductOptionsSignal = signalsService.signal(getAvailableProductOptions(aggregationData, customizations));
+    const selectedProductOptionsSignal = signalsService.signal(initialSearchState?.productOptions || {});
+    const selectedCategorySignal = signalsService.signal(initialSearchState?.category || null);
+    const selectedVisibleSignal = signalsService.signal(initialSearchState?.visible ?? null);
+    const selectedProductTypeSignal = signalsService.signal(initialSearchState?.productType || null);
+    const isFilteredSignal = signalsService.signal(false);
+    // Computed signals for pagination
+    const hasNextPageSignal = signalsService.computed(() => {
+        const pagingMetadata = productsListService.pagingMetadata.get();
+        return pagingMetadata?.hasNext || false;
+    });
+    const hasPrevPageSignal = signalsService.computed(() => {
+        const pagingMetadata = productsListService.pagingMetadata.get();
+        return typeof pagingMetadata.cursors?.prev !== "undefined";
+    });
+    // Debounce timeout IDs for price filters
+    let minPriceTimeoutId = null;
+    let maxPriceTimeoutId = null;
+    if (typeof window !== "undefined") {
+        // Watch for changes in any search parameters and update search options
+        signalsService.effect(() => {
+            // Read all signals to establish dependencies
+            const sort = selectedSortOptionSignal.get();
+            const limit = currentLimitSignal.get();
+            const cursor = currentCursorSignal.get();
+            const minPrice = userFilterMinPriceSignal.get();
+            const maxPrice = userFilterMaxPriceSignal.get();
+            const selectedInventoryStatuses = selectedInventoryStatusesSignal.get();
+            const selectedProductOptions = selectedProductOptionsSignal.get();
+            const selectedCategory = selectedCategorySignal.get();
+            const selectedVisible = selectedVisibleSignal.get();
+            const selectedProductType = selectedProductTypeSignal.get();
+            if (firstRun) {
+                firstRun = false;
+                return;
+            }
+            // Build complete new search options
+            const newSearchOptions = {
+                ...productsListService.searchOptions.peek(),
+            };
+            // Update pagination
+            if (limit > 0) {
+                newSearchOptions.cursorPaging = {
+                    limit,
+                    ...(cursor && { cursor }),
+                };
+            }
+            else {
+                delete newSearchOptions.cursorPaging;
+            }
+            // Update sort
+            switch (sort) {
+                case SortType.NAME_ASC:
+                    newSearchOptions.sort = [
+                        { fieldName: "name", order: productsV3.SortDirection.ASC },
+                    ];
+                    break;
+                case SortType.NAME_DESC:
+                    newSearchOptions.sort = [
+                        { fieldName: "name", order: productsV3.SortDirection.DESC },
+                    ];
+                    break;
+                case SortType.PRICE_ASC:
+                    newSearchOptions.sort = [
+                        {
+                            fieldName: "actualPriceRange.minValue.amount",
+                            order: productsV3.SortDirection.ASC,
+                        },
+                    ];
+                    break;
+                case SortType.PRICE_DESC:
+                    newSearchOptions.sort = [
+                        {
+                            fieldName: "actualPriceRange.minValue.amount",
+                            order: productsV3.SortDirection.DESC,
+                        },
+                    ];
+                    break;
+                case SortType.RECOMMENDED:
+                    newSearchOptions.sort = [
+                        {
+                            fieldName: "name",
+                            order: productsV3.SortDirection.DESC,
+                        },
+                    ];
+                    break;
+            }
+            // Update filters
+            if (!newSearchOptions.filter) {
+                newSearchOptions.filter = {};
+            }
+            else {
+                newSearchOptions.filter = { ...newSearchOptions.filter };
+            }
+            // Remove existing filters
+            delete newSearchOptions.filter["actualPriceRange.minValue.amount"];
+            delete newSearchOptions.filter["actualPriceRange.maxValue.amount"];
+            delete newSearchOptions.filter["inventory.availabilityStatus"];
+            delete newSearchOptions.filter["allCategoriesInfo.categories"];
+            delete newSearchOptions.filter["visible"];
+            delete newSearchOptions.filter["productType"];
+            // Remove existing product option filters
+            Object.keys(newSearchOptions.filter).forEach((key) => {
+                if (key.startsWith("options.")) {
+                    delete newSearchOptions.filter[key];
+                }
+            });
+            // Add new filters
+            if (minPrice > 0) {
+                newSearchOptions.filter["actualPriceRange.minValue.amount"] = { $gte: minPrice };
+            }
+            if (maxPrice > 0) {
+                newSearchOptions.filter["actualPriceRange.maxValue.amount"] = { $lte: maxPrice };
+            }
+            if (selectedInventoryStatuses.length > 0) {
+                if (selectedInventoryStatuses.length === 1) {
+                    newSearchOptions.filter["inventory.availabilityStatus"] =
+                        selectedInventoryStatuses[0];
+                }
+                else {
+                    newSearchOptions.filter["inventory.availabilityStatus"] =
+                        { $in: selectedInventoryStatuses };
+                }
+            }
+            if (selectedProductOptions &&
+                Object.keys(selectedProductOptions).length > 0) {
+                const allChoiceIds = [];
+                for (const choiceIds of Object.values(selectedProductOptions)) {
+                    allChoiceIds.push(...choiceIds);
+                }
+                if (allChoiceIds.length > 0) {
+                    newSearchOptions.filter["options.choicesSettings.choices.choiceId"] = { $hasSome: allChoiceIds };
+                }
+            }
+            if (selectedCategory) {
+                newSearchOptions.filter["allCategoriesInfo.categories"] = {
+                    $matchItems: [{ _id: { $in: [selectedCategory._id] } }],
+                };
+            }
+            if (selectedVisible !== null) {
+                newSearchOptions.filter["visible"] = selectedVisible;
+            }
+            if (selectedProductType) {
+                newSearchOptions.filter["productType"] =
+                    selectedProductType;
+            }
+            // Update the products list service
+            productsListService.setSearchOptions(newSearchOptions);
+            // Update URL with current search state
+            const catalogBounds = {
+                minPrice: catalogMinPriceSignal.get(),
+                maxPrice: catalogMaxPriceSignal.get(),
+            };
+            const currentFilters = {
+                priceRange: { min: minPrice, max: maxPrice },
+                inventoryStatuses: selectedInventoryStatuses,
+                productOptions: selectedProductOptions,
+                ...(selectedVisible !== null && { visible: selectedVisible }),
+                ...(selectedProductType && { productType: selectedProductType }),
+            };
+            updateUrlWithSearchState({
+                sort,
+                filters: currentFilters,
+                customizations,
+                catalogBounds,
+                categorySlug: selectedCategory?.slug || undefined,
+            });
+        });
+    }
+    return {
+        // Sort functionality
+        selectedSortOption: selectedSortOptionSignal,
+        sortOptions: Object.values(SortType),
+        setSelectedSortOption: (sort) => selectedSortOptionSignal.set(sort),
+        // Pagination functionality
+        currentLimit: currentLimitSignal,
+        currentCursor: currentCursorSignal,
+        hasNextPage: hasNextPageSignal,
+        hasPrevPage: hasPrevPageSignal,
+        setLimit: (limit) => {
+            currentLimitSignal.set(limit);
+            currentCursorSignal.set(null); // Reset pagination when changing page size
+        },
+        loadMore: (count) => {
+            const limit = currentLimitSignal.get();
+            currentLimitSignal.set(limit + count);
+        },
+        nextPage: () => {
+            const pagingMetadata = productsListService.pagingMetadata.get();
+            const nextCursor = pagingMetadata?.cursors?.next;
+            if (nextCursor) {
+                currentCursorSignal.set(nextCursor);
+            }
+        },
+        prevPage: () => {
+            const pagingMetadata = productsListService.pagingMetadata.get();
+            const previousCursor = pagingMetadata?.cursors?.prev;
+            if (previousCursor) {
+                currentCursorSignal.set(previousCursor);
+            }
+        },
+        navigateToFirstPage: () => {
+            currentCursorSignal.set(null);
+        },
+        // Filter functionality
+        selectedMinPrice: userFilterMinPriceSignal,
+        selectedMaxPrice: userFilterMaxPriceSignal,
+        availableMinPrice: catalogMinPriceSignal,
+        availableMaxPrice: catalogMaxPriceSignal,
+        availableInventoryStatuses: availableInventoryStatusesSignal,
+        selectedInventoryStatuses: selectedInventoryStatusesSignal,
+        availableProductOptions: availableProductOptionsSignal,
+        selectedProductOptions: selectedProductOptionsSignal,
+        selectedCategory: selectedCategorySignal,
+        setSelectedMinPrice: (minPrice) => {
+            if (minPriceTimeoutId) {
+                clearTimeout(minPriceTimeoutId);
+            }
+            minPriceTimeoutId = setTimeout(() => {
+                userFilterMinPriceSignal.set(minPrice);
+                minPriceTimeoutId = null;
+            }, PRICE_FILTER_DEBOUNCE_TIME);
+        },
+        setSelectedMaxPrice: (maxPrice) => {
+            if (maxPriceTimeoutId) {
+                clearTimeout(maxPriceTimeoutId);
+            }
+            maxPriceTimeoutId = setTimeout(() => {
+                userFilterMaxPriceSignal.set(maxPrice);
+                maxPriceTimeoutId = null;
+            }, PRICE_FILTER_DEBOUNCE_TIME);
+        },
+        toggleInventoryStatus: (status) => {
+            const current = selectedInventoryStatusesSignal.get();
+            const isSelected = current.includes(status);
+            if (isSelected) {
+                selectedInventoryStatusesSignal.set(current.filter((s) => s !== status));
+            }
+            else {
+                selectedInventoryStatusesSignal.set([...current, status]);
+            }
+        },
+        toggleProductOption: (optionId, choiceId) => {
+            const current = selectedProductOptionsSignal.get();
+            const currentChoices = current[optionId] || [];
+            const isSelected = currentChoices.includes(choiceId);
+            if (isSelected) {
+                const newChoices = currentChoices.filter((id) => id !== choiceId);
+                if (newChoices.length === 0) {
+                    const newOptions = { ...current };
+                    delete newOptions[optionId];
+                    selectedProductOptionsSignal.set(newOptions);
+                }
+                else {
+                    selectedProductOptionsSignal.set({
+                        ...current,
+                        [optionId]: newChoices,
+                    });
+                }
+            }
+            else {
+                selectedProductOptionsSignal.set({
+                    ...current,
+                    [optionId]: [...currentChoices, choiceId],
+                });
+            }
+        },
+        setSelectedCategory: (category) => {
+            selectedCategorySignal.set(category);
+        },
+        setSelectedVisible: (visible) => {
+            selectedVisibleSignal.set(visible);
+        },
+        setSelectedProductType: (productType) => {
+            selectedProductTypeSignal.set(productType);
+        },
+        isFiltered: isFilteredSignal,
+        reset: () => {
+            selectedSortOptionSignal.set(SortType.NAME_ASC);
+            currentLimitSignal.set(DEFAULT_QUERY_LIMIT);
+            currentCursorSignal.set(null);
+            userFilterMinPriceSignal.set(catalogMinPriceSignal.get());
+            userFilterMaxPriceSignal.set(catalogMaxPriceSignal.get());
+            selectedInventoryStatusesSignal.set([]);
+            selectedProductOptionsSignal.set({});
+            selectedCategorySignal.set(null);
+            selectedVisibleSignal.set(null);
+            selectedProductTypeSignal.set(null);
+            isFilteredSignal.set(false);
+        },
+    };
+});
+// Helper functions (copied from the original services)
+function getCurrentLimit(searchOptions) {
+    return searchOptions.cursorPaging?.limit || DEFAULT_QUERY_LIMIT;
+}
+function getCurrentCursor(searchOptions) {
+    return searchOptions.cursorPaging?.cursor || null;
+}
+function getCatalogPriceRange(aggregationData) {
+    const minPrice = getMinPrice(aggregationData);
+    const maxPrice = getMaxPrice(aggregationData);
+    return { minPrice, maxPrice };
+}
+function getMinPrice(aggregationData) {
+    const minPriceAggregation = aggregationData.find((data) => data.fieldPath === "actualPriceRange.minValue.amount");
+    if (minPriceAggregation?.scalar?.value) {
+        return Number(minPriceAggregation.scalar.value) || 0;
+    }
+    return 0;
+}
+function getMaxPrice(aggregationData) {
+    const maxPriceAggregation = aggregationData.find((data) => data.fieldPath === "actualPriceRange.maxValue.amount");
+    if (maxPriceAggregation?.scalar?.value) {
+        return Number(maxPriceAggregation.scalar.value) || 0;
+    }
+    return 0;
+}
+function getAvailableProductOptions(aggregationData = [], customizations = []) {
+    const matchesAggregationName = (name, aggregationNames) => {
+        return aggregationNames.some((aggName) => aggName.toLowerCase() === name.toLowerCase());
+    };
+    const sortChoicesIntelligently = (choices) => {
+        return [...choices].sort((a, b) => {
+            const aIsNumber = /^\d+$/.test(a.name);
+            const bIsNumber = /^\d+$/.test(b.name);
+            if (aIsNumber && bIsNumber) {
+                return parseInt(a.name) - parseInt(b.name);
+            }
+            if (aIsNumber && !bIsNumber)
+                return -1;
+            if (!aIsNumber && bIsNumber)
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+    };
+    const optionNames = [];
+    const choiceNames = [];
+    aggregationData.forEach((result) => {
+        if (result.name === "optionNames" && result.values?.results) {
+            optionNames.push(...result.values.results
+                .map((item) => item.value)
+                .filter((value) => typeof value === "string"));
+        }
+        if (result.name === "choiceNames" && result.values?.results) {
+            choiceNames.push(...result.values.results
+                .map((item) => item.value)
+                .filter((value) => typeof value === "string"));
+        }
+    });
+    const options = customizations
+        .filter((customization) => customization.name &&
+        customization._id &&
+        customization.customizationType ===
+            customizationsV3.CustomizationType.PRODUCT_OPTION &&
+        (optionNames.length === 0 ||
+            matchesAggregationName(customization.name, optionNames)))
+        .map((customization) => {
+        const choices = (customization.choicesSettings?.choices || [])
+            .filter((choice) => choice._id &&
+            choice.name &&
+            (choiceNames.length === 0 ||
+                matchesAggregationName(choice.name, choiceNames)))
+            .map((choice) => ({
+            id: choice._id,
+            name: choice.name,
+            colorCode: choice.colorCode,
+        }));
+        return {
+            id: customization._id,
+            name: customization.name,
+            choices: sortChoicesIntelligently(choices),
+            optionRenderType: customization.customizationRenderType,
+        };
+    })
+        .filter((option) => option.choices.length > 0);
+    return options;
+}