@wix/headless-stores 0.0.8 → 0.0.10

package/cjs/dist/services/collection-service.js

@@ -0,0 +1,454 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionService = exports.CollectionServiceDefinition = void 0;
+exports.loadCollectionServiceConfig = loadCollectionServiceConfig;
+const services_definitions_1 = require("@wix/services-definitions");
+const signals_1 = require("@wix/services-definitions/core-services/signals");
+const stores_1 = require("@wix/stores");
+const filter_service_1 = require("./filter-service");
+const category_service_1 = require("./category-service");
+const sort_service_1 = require("./sort-service");
+const url_params_1 = require("../utils/url-params");
+const searchProducts = async (searchOptions) => {
+    const searchParams = {
+        filter: searchOptions.search?.filter,
+        sort: searchOptions.search?.sort,
+        ...(searchOptions.paging && { cursorPaging: searchOptions.paging }),
+    };
+    const options = {
+        fields: searchOptions.fields || [],
+    };
+    // @ts-ignore
+    return await stores_1.productsV3.searchProducts(searchParams, options);
+};
+// Helper to build search options with supported filters
+const buildSearchOptions = (filters, selectedCategory, sortBy, 
+// @ts-ignore
+categories) => {
+    const searchOptions = {
+        search: {},
+        fields: [
+            "PLAIN_DESCRIPTION",
+            "MEDIA_ITEMS_INFO",
+            "CURRENCY",
+            "THUMBNAIL",
+            "URL",
+            "ALL_CATEGORIES_INFO",
+        ],
+    };
+    // Build filter conditions array
+    const filterConditions = [];
+    // Add category filter if selected
+    if (selectedCategory) {
+        filterConditions.push({
+            "allCategoriesInfo.categories": {
+                $matchItems: [
+                    {
+                        id: {
+                            $in: [selectedCategory],
+                        },
+                    },
+                ],
+            },
+        });
+    }
+    // Add price range filter if provided
+    if (filters?.priceRange) {
+        const { min, max } = filters.priceRange;
+        if (min > 0) {
+            filterConditions.push({
+                "actualPriceRange.minValue.amount": { $gte: min.toString() },
+            });
+        }
+        if (max > 0 && max < 999999) {
+            filterConditions.push({
+                "actualPriceRange.maxValue.amount": { $lte: max.toString() },
+            });
+        }
+    }
+    // Add product options filter if provided
+    if (filters?.selectedOptions &&
+        Object.keys(filters.selectedOptions).length > 0) {
+        for (const [optionId, choiceIds] of Object.entries(filters.selectedOptions)) {
+            if (choiceIds.length > 0) {
+                // Handle inventory filter separately
+                if (optionId === "inventory-filter") {
+                    filterConditions.push({
+                        "inventory.availabilityStatus": {
+                            $in: choiceIds,
+                        },
+                    });
+                }
+                else {
+                    // Regular product options filter
+                    filterConditions.push({
+                        "options.choicesSettings.choices.choiceId": {
+                            $hasSome: choiceIds,
+                        },
+                    });
+                }
+            }
+        }
+    }
+    // Apply filters
+    if (filterConditions.length > 0) {
+        if (filterConditions.length === 1) {
+            // Single condition - no need for $and wrapper
+            searchOptions.search.filter = filterConditions[0];
+        }
+        else {
+            // Multiple conditions - use $and
+            searchOptions.search.filter = {
+                $and: filterConditions,
+            };
+        }
+    }
+    // Add sort if provided
+    if (sortBy) {
+        switch (sortBy) {
+            case "name-asc":
+                searchOptions.search.sort = [{ fieldName: "name", order: "ASC" }];
+                break;
+            case "name-desc":
+                searchOptions.search.sort = [{ fieldName: "name", order: "DESC" }];
+                break;
+            case "price-asc":
+                searchOptions.search.sort = [
+                    { fieldName: "actualPriceRange.minValue.amount", order: "ASC" },
+                ];
+                break;
+            case "price-desc":
+                searchOptions.search.sort = [
+                    { fieldName: "actualPriceRange.minValue.amount", order: "DESC" },
+                ];
+                break;
+        }
+    }
+    return searchOptions;
+};
+exports.CollectionServiceDefinition = (0, services_definitions_1.defineService)("collection");
+exports.CollectionService = services_definitions_1.implementService.withConfig()(exports.CollectionServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(signals_1.SignalsServiceDefinition);
+    const collectionFilters = getService(filter_service_1.FilterServiceDefinition);
+    const categoryService = getService(category_service_1.CategoryServiceDefinition);
+    const sortService = getService(sort_service_1.SortServiceDefinition);
+    const hasMoreProducts = signalsService.signal((config.initialHasMore ?? true));
+    let nextCursor = config.initialCursor;
+    const initialProducts = config.initialProducts || [];
+    // Signal declarations
+    const productsList = signalsService.signal(initialProducts);
+    const isLoading = signalsService.signal(false);
+    const error = signalsService.signal(null);
+    const totalProducts = signalsService.signal(initialProducts.length);
+    const hasProducts = signalsService.signal((initialProducts.length > 0));
+    const pageSize = config.pageSize || 12;
+    let allProducts = initialProducts;
+    // Debouncing mechanism to prevent multiple simultaneous refreshes
+    let refreshTimeout = null;
+    let isRefreshing = false;
+    let isInitializingCatalogData = true;
+    const loadMore = async () => {
+        // Don't load more if there are no more products available
+        if (!hasMoreProducts.get()) {
+            return;
+        }
+        try {
+            isLoading.set(true);
+            error.set(null);
+            // For loadMore, use no filters or sorting to work with cursor pagination
+            const searchOptions = buildSearchOptions(undefined, undefined, undefined, undefined);
+            // Add pagination
+            searchOptions.paging = { limit: pageSize };
+            if (nextCursor) {
+                searchOptions.paging.cursor = nextCursor;
+            }
+            const currentProducts = productsList.get();
+            const productResults = await searchProducts(searchOptions);
+            // Update cursor for next pagination
+            nextCursor = productResults.pagingMetadata?.cursors?.next || undefined;
+            // Check if there are more products to load
+            const hasMore = Boolean(nextCursor &&
+                productResults.products &&
+                productResults.products.length === pageSize);
+            hasMoreProducts.set(hasMore);
+            // Update allProducts with the new data
+            allProducts = [...allProducts, ...(productResults.products || [])];
+            // Add new products to the list
+            const additionalProducts = productResults.products || [];
+            productsList.set([...currentProducts, ...additionalProducts]);
+            totalProducts.set(currentProducts.length + additionalProducts.length);
+            hasProducts.set(currentProducts.length + additionalProducts.length > 0);
+        }
+        catch (err) {
+            error.set(err instanceof Error ? err.message : "Failed to load more products");
+        }
+        finally {
+            isLoading.set(false);
+        }
+    };
+    const refresh = async (setTotalProducts = true) => {
+        if (isRefreshing)
+            return;
+        try {
+            isRefreshing = true;
+            isLoading.set(true);
+            error.set(null);
+            const filters = collectionFilters.currentFilters.get();
+            const selectedCategory = categoryService.selectedCategory.get();
+            const sortBy = sortService.currentSort.get();
+            const categories = config.categories || categoryService.categories.get();
+            const searchOptions = buildSearchOptions(filters, selectedCategory, sortBy, categories);
+            // Add pagination
+            searchOptions.paging = { limit: pageSize };
+            const productResults = await searchProducts(searchOptions);
+            // Reset pagination state
+            nextCursor = productResults.pagingMetadata?.cursors?.next || undefined;
+            const hasMore = Boolean(productResults.pagingMetadata?.cursors?.next &&
+                productResults.products &&
+                productResults.products.length === pageSize);
+            hasMoreProducts.set(hasMore);
+            // Update allProducts with the new data
+            allProducts = productResults.products || [];
+            // All filtering is handled server-side
+            productsList.set(allProducts);
+            if (setTotalProducts) {
+                totalProducts.set(allProducts.length);
+            }
+            hasProducts.set(allProducts.length > 0);
+        }
+        catch (err) {
+            error.set(err instanceof Error ? err.message : "Failed to refresh products");
+        }
+        finally {
+            isLoading.set(false);
+            isRefreshing = false;
+        }
+    };
+    // Debounced refresh function
+    const debouncedRefresh = async (setTotalProducts = true) => {
+        if (refreshTimeout) {
+            clearTimeout(refreshTimeout);
+        }
+        return new Promise((resolve) => {
+            refreshTimeout = setTimeout(async () => {
+                await refresh(setTotalProducts);
+                resolve();
+            }, 50); // 50ms debounce delay
+        });
+    };
+    // Refresh with server-side filtering when any filters change
+    collectionFilters.currentFilters.subscribe(() => {
+        // Skip refresh during catalog data initialization to prevent double API calls
+        if (isInitializingCatalogData) {
+            return;
+        }
+        // All filtering (categories, price, options) is now handled server-side
+        debouncedRefresh(false);
+    });
+    // Initialize catalog data when the service starts
+    const initializeCatalogData = async () => {
+        const selectedCategory = categoryService.selectedCategory.get();
+        await collectionFilters.loadCatalogPriceRange(selectedCategory || undefined);
+        await collectionFilters.loadCatalogOptions(selectedCategory || undefined);
+        // Reset flag to allow filter changes to trigger refreshes
+        isInitializingCatalogData = false;
+    };
+    // Load catalog data on initialization
+    void initializeCatalogData();
+    sortService.currentSort.subscribe(() => {
+        debouncedRefresh(false);
+    });
+    return {
+        products: productsList,
+        isLoading,
+        error,
+        totalProducts,
+        hasProducts,
+        hasMoreProducts,
+        loadMore,
+        refresh: debouncedRefresh,
+    };
+});
+// Helper function to parse URL parameters
+function parseURLParams(searchParams, products = []) {
+    const defaultFilters = {
+        priceRange: { min: 0, max: 0 },
+        selectedOptions: {},
+    };
+    if (!searchParams) {
+        return { initialSort: "", initialFilters: defaultFilters };
+    }
+    const urlParams = url_params_1.URLParamsUtils.parseSearchParams(searchParams);
+    // Parse sort parameter
+    const sortMap = {
+        name_asc: "name-asc",
+        name_desc: "name-desc",
+        price_asc: "price-asc",
+        price_desc: "price-desc",
+    };
+    const initialSort = sortMap[urlParams["sort"]] || "";
+    // Check if there are any filter parameters (excluding sort)
+    const filterParams = Object.keys(urlParams).filter((key) => key !== "sort");
+    if (filterParams.length === 0 || products.length === 0) {
+        return { initialSort, initialFilters: defaultFilters };
+    }
+    // Calculate available price range from products
+    const priceRange = calculatePriceRange(products);
+    const initialFilters = {
+        priceRange,
+        selectedOptions: {},
+    };
+    // Apply price filters from URL
+    if (urlParams["minPrice"]) {
+        const min = parseFloat(urlParams["minPrice"]);
+        if (!isNaN(min))
+            initialFilters.priceRange.min = min;
+    }
+    if (urlParams["maxPrice"]) {
+        const max = parseFloat(urlParams["maxPrice"]);
+        if (!isNaN(max))
+            initialFilters.priceRange.max = max;
+    }
+    // Parse option filters
+    const optionsMap = buildOptionsMap(products);
+    parseOptionFilters(urlParams, optionsMap, initialFilters);
+    // Parse inventory filter from 'availability' URL parameter
+    if (urlParams["availability"]) {
+        const availabilityValues = Array.isArray(urlParams["availability"])
+            ? urlParams["availability"]
+            : [urlParams["availability"]];
+        const inventoryStatusValues = availabilityValues.map((value) => value.replace(/\s+/g, "_").toUpperCase());
+        initialFilters.selectedOptions["inventory-filter"] = inventoryStatusValues;
+    }
+    return { initialSort, initialFilters };
+}
+// Helper function to calculate price range from products
+function calculatePriceRange(products) {
+    if (products.length === 0) {
+        return { min: 0, max: 1000 };
+    }
+    let minPrice = Infinity;
+    let maxPrice = 0;
+    products.forEach((product) => {
+        const min = parseFloat(product.actualPriceRange?.minValue?.amount || "0");
+        const max = parseFloat(product.actualPriceRange?.maxValue?.amount || "0");
+        if (min > 0)
+            minPrice = Math.min(minPrice, min);
+        if (max > 0)
+            maxPrice = Math.max(maxPrice, max);
+    });
+    // If no valid prices found, return default range
+    if (minPrice === Infinity) {
+        minPrice = 0;
+        maxPrice = 1000;
+    }
+    return { min: minPrice, max: maxPrice };
+}
+// Helper function to build options map from products
+function buildOptionsMap(products) {
+    const optionsMap = new Map();
+    products.forEach((product) => {
+        product.options?.forEach((option) => {
+            if (!option._id || !option.name)
+                return;
+            if (!optionsMap.has(option.name)) {
+                optionsMap.set(option.name, { id: option._id, choices: [] });
+            }
+            const optionData = optionsMap.get(option.name);
+            option.choicesSettings?.choices?.forEach((choice) => {
+                if (choice.choiceId &&
+                    choice.name &&
+                    !optionData.choices.find((c) => c.id === choice.choiceId)) {
+                    optionData.choices.push({ id: choice.choiceId, name: choice.name });
+                }
+            });
+        });
+    });
+    return optionsMap;
+}
+// Helper function to parse option filters from URL parameters
+function parseOptionFilters(urlParams, optionsMap, filters) {
+    Object.entries(urlParams).forEach(([key, value]) => {
+        if (["sort", "minPrice", "maxPrice"].includes(key))
+            return;
+        const option = optionsMap.get(key);
+        if (option) {
+            const values = Array.isArray(value) ? value : [value];
+            const matchingChoices = option.choices.filter((choice) => values.includes(choice.name));
+            if (matchingChoices.length > 0) {
+                filters.selectedOptions[option.id] = matchingChoices.map((c) => c.id);
+            }
+        }
+    });
+}
+async function loadCollectionServiceConfig(categoryId, searchParams) {
+    try {
+        // Load categories for service configuration
+        const { loadCategoriesConfig } = await Promise.resolve().then(() => __importStar(require("./category-service")));
+        const categoriesConfig = await loadCategoriesConfig();
+        const categories = categoriesConfig.categories;
+        // Build search options with category filter
+        const searchOptions = buildSearchOptions(undefined, categoryId, undefined, categories);
+        const pageSize = 12;
+        searchOptions.paging = { limit: pageSize };
+        const productResults = await searchProducts(searchOptions);
+        // Parse URL parameters for initial state
+        const { initialSort, initialFilters } = parseURLParams(searchParams, productResults.products || []);
+        return {
+            initialProducts: productResults.products || [],
+            pageSize,
+            initialCursor: productResults.pagingMetadata?.cursors?.next || undefined,
+            initialHasMore: Boolean(productResults.pagingMetadata?.cursors?.next &&
+                productResults.products &&
+                productResults.products.length === pageSize),
+            initialSort,
+            initialFilters,
+            categories,
+        };
+    }
+    catch (error) {
+        console.warn("Failed to load initial products:", error);
+        const { initialSort, initialFilters } = parseURLParams(searchParams);
+        return {
+            initialProducts: [],
+            pageSize: 12,
+            initialHasMore: false,
+            initialSort,
+            initialFilters,
+            categories: [],
+        };
+    }
+}

package/cjs/dist/services/filter-service.d.ts

@@ -0,0 +1,56 @@
+import type { Signal } from "./Signal";
+export interface ProductOption {
+    id: string;
+    name: string;
+    choices: {
+        id: string;
+        name: string;
+        colorCode?: string;
+    }[];
+    optionRenderType?: string;
+}
+export interface PriceRange {
+    min: number;
+    max: number;
+}
+export interface AvailableOptions {
+    productOptions: ProductOption[];
+    priceRange: PriceRange;
+}
+export interface Filter {
+    priceRange: {
+        min: number;
+        max: number;
+    };
+    selectedOptions: {
+        [optionId: string]: string[];
+    };
+}
+export interface FilterServiceAPI {
+    currentFilters: Signal<Filter>;
+    applyFilters: (filters: Filter) => Promise<void>;
+    clearFilters: () => Promise<void>;
+    availableOptions: Signal<{
+        productOptions: ProductOption[];
+        priceRange: {
+            min: number;
+            max: number;
+        };
+    }>;
+    loadCatalogPriceRange: (categoryId?: string) => Promise<void>;
+    loadCatalogOptions: (categoryId?: string) => Promise<void>;
+    isFullyLoaded: Signal<boolean>;
+}
+export declare const FilterServiceDefinition: string & {
+    __api: FilterServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & FilterServiceAPI;
+export declare const defaultFilter: Filter;
+export declare const FilterService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: FilterServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & FilterServiceAPI, {
+    initialFilters?: Filter;
+}, import("@wix/services-definitions").ThreadMode.MAIN>;

package/cjs/dist/services/filter-service.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterService = exports.defaultFilter = exports.FilterServiceDefinition = void 0;
+const services_definitions_1 = require("@wix/services-definitions");
+const signals_1 = require("@wix/services-definitions/core-services/signals");
+const url_params_1 = require("../utils/url-params");
+const catalog_price_range_service_1 = require("./catalog-price-range-service");
+const catalog_options_service_1 = require("./catalog-options-service");
+exports.FilterServiceDefinition = (0, services_definitions_1.defineService)("filtered-collection");
+exports.defaultFilter = {
+    priceRange: { min: 0, max: 0 },
+    selectedOptions: {},
+};
+exports.FilterService = services_definitions_1.implementService.withConfig()(exports.FilterServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(signals_1.SignalsServiceDefinition);
+    const catalogPriceRangeService = getService(catalog_price_range_service_1.CatalogPriceRangeServiceDefinition);
+    const catalogOptionsService = getService(catalog_options_service_1.CatalogOptionsServiceDefinition);
+    const currentFilters = signalsService.signal((config.initialFilters || exports.defaultFilter));
+    const availableOptions = signalsService.signal({
+        productOptions: [],
+        priceRange: { min: 0, max: 0 },
+    });
+    const isFullyLoaded = signalsService.signal(false);
+    // Helper function to check if both catalog data are loaded
+    const checkIfFullyLoaded = () => {
+        const catalogPriceRange = catalogPriceRangeService.catalogPriceRange.get();
+        const catalogOptions = catalogOptionsService.catalogOptions.get();
+        // Price range data is considered loaded whether it's null (no prices) or has valid data
+        const hasPriceRangeData = catalogPriceRange !== undefined; // includes null case
+        const hasOptionsData = !!(catalogOptions && catalogOptions.length >= 0); // Even 0 options is valid
+        isFullyLoaded.set(hasPriceRangeData && hasOptionsData);
+    };
+    // Subscribe to catalog price range changes and automatically update our signals
+    catalogPriceRangeService.catalogPriceRange.subscribe((catalogPriceRange) => {
+        if (catalogPriceRange &&
+            catalogPriceRange.minPrice < catalogPriceRange.maxPrice) {
+            const priceRange = {
+                min: catalogPriceRange.minPrice,
+                max: catalogPriceRange.maxPrice,
+            };
+            // Update available options with catalog price range
+            const currentAvailableOptions = availableOptions.get();
+            availableOptions.set({
+                ...currentAvailableOptions,
+                priceRange,
+            });
+            // Update current filters to use catalog price range
+            const currentFiltersValue = currentFilters.get();
+            // Only update if current filter range is at defaults (either 0-0 or 0-1000)
+            const isDefaultRange = (currentFiltersValue.priceRange.min === 0 &&
+                currentFiltersValue.priceRange.max === 0) ||
+                (currentFiltersValue.priceRange.min === 0 &&
+                    currentFiltersValue.priceRange.max === 1000);
+            if (isDefaultRange) {
+                currentFilters.set({
+                    ...currentFiltersValue,
+                    priceRange,
+                });
+            }
+        }
+        // Check if fully loaded after price range update
+        checkIfFullyLoaded();
+    });
+    // Subscribe to catalog options changes and automatically update our signals
+    catalogOptionsService.catalogOptions.subscribe((catalogOptions) => {
+        if (catalogOptions && catalogOptions.length > 0) {
+            // Update available options with catalog options
+            const currentAvailableOptions = availableOptions.get();
+            availableOptions.set({
+                ...currentAvailableOptions,
+                productOptions: catalogOptions,
+            });
+        }
+        // Check if fully loaded after options update
+        checkIfFullyLoaded();
+    });
+    // Apply filters by delegating to the collection service
+    const applyFilters = async (filters) => {
+        currentFilters.set(filters);
+        // Update URL with filter parameters
+        const urlParams = {};
+        const availableOpts = availableOptions.get();
+        // Add price filters if different from defaults
+        if (availableOpts?.priceRange) {
+            if (filters.priceRange.min > availableOpts.priceRange.min) {
+                urlParams["minPrice"] = filters.priceRange.min.toString();
+            }
+            if (filters.priceRange.max < availableOpts.priceRange.max) {
+                urlParams["maxPrice"] = filters.priceRange.max.toString();
+            }
+        }
+        // Add option filters using option names as keys
+        if (availableOpts?.productOptions) {
+            Object.entries(filters.selectedOptions).forEach(([optionId, choiceIds]) => {
+                const option = availableOpts.productOptions.find((opt) => opt.id === optionId);
+                if (option && choiceIds.length > 0) {
+                    const selectedChoices = option.choices.filter((choice) => choiceIds.includes(choice.id));
+                    if (selectedChoices.length > 0) {
+                        // Use 'availability' as URL param for inventory filter
+                        const paramName = optionId === "inventory-filter" ? "availability" : option.name;
+                        urlParams[paramName] = selectedChoices.map((choice) => choice.name);
+                    }
+                }
+            });
+        }
+        // Preserve existing sort parameter
+        const currentParams = url_params_1.URLParamsUtils.getURLParams();
+        if (currentParams["sort"]) {
+            urlParams["sort"] = currentParams["sort"];
+        }
+        url_params_1.URLParamsUtils.updateURL(urlParams);
+    };
+    // Clear all filters by applying default filter state
+    const clearFilters = async () => {
+        const availablePriceRange = availableOptions.get()?.priceRange;
+        currentFilters.set({
+            ...exports.defaultFilter,
+            priceRange: availablePriceRange || { min: 0, max: 0 },
+        });
+        // Clear filter parameters from URL, keeping only sort parameter
+        const currentParams = url_params_1.URLParamsUtils.getURLParams();
+        const urlParams = {};
+        if (currentParams["sort"]) {
+            urlParams["sort"] = currentParams["sort"];
+        }
+        url_params_1.URLParamsUtils.updateURL(urlParams);
+    };
+    // const calculateAvailableOptions = async (
+    //   products: productsV3.V3Product[]
+    // ) => {
+    //   // No longer calculating options from current page products
+    //   // Options are now loaded from the catalog-wide service
+    //   // This function is kept for backward compatibility but does nothing
+    //   console.log(
+    //     "🔄 calculateAvailableOptions called but using catalog-wide options instead"
+    //   );
+    // };
+    const loadCatalogPriceRange = async (categoryId) => {
+        // Just call the catalog service - subscriptions will handle signal updates
+        await catalogPriceRangeService.loadCatalogPriceRange(categoryId);
+    };
+    const loadCatalogOptions = async (categoryId) => {
+        // Just call the catalog service - subscriptions will handle signal updates
+        await catalogOptionsService.loadCatalogOptions(categoryId);
+    };
+    return {
+        currentFilters,
+        applyFilters,
+        clearFilters,
+        availableOptions,
+        loadCatalogPriceRange,
+        loadCatalogOptions,
+        isFullyLoaded,
+    };
+});

package/cjs/dist/services/product-media-gallery-service.d.ts

@@ -0,0 +1,25 @@
+import { type ServiceFactoryConfig } from "@wix/services-definitions";
+import type { Signal, ReadOnlySignal } from "./Signal";
+import { productsV3 } from "@wix/stores";
+export interface ProductMediaGalleryServiceAPI {
+    selectedImageIndex: Signal<number>;
+    relevantImages: ReadOnlySignal<string[]>;
+    product: ReadOnlySignal<productsV3.V3Product | null>;
+    isLoading: ReadOnlySignal<boolean>;
+    totalImages: ReadOnlySignal<number>;
+    productName: ReadOnlySignal<string>;
+    setSelectedImageIndex: (index: number) => void;
+    nextImage: () => void;
+    previousImage: () => void;
+}
+export declare const ProductMediaGalleryServiceDefinition: string & {
+    __api: ProductMediaGalleryServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ProductMediaGalleryServiceAPI;
+export declare const ProductMediaGalleryService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: ProductMediaGalleryServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ProductMediaGalleryServiceAPI, {}, import("@wix/services-definitions").ThreadMode.MAIN>;
+export declare function loadProductMediaGalleryServiceConfig(productSlug: string): Promise<ServiceFactoryConfig<typeof ProductMediaGalleryService>>;