@wix/headless-stores 0.0.52 → 0.0.53

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

@@ -1,11 +1,11 @@
-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";
+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";
+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.
@@ -15,44 +15,44 @@ 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");
+export const ProductsListSearchServiceDefinition = defineService('products-list-search');
 /**
  * Convert SortType enum to URL format
  */
 function convertSortTypeToUrl(sortType) {
     switch (sortType) {
         case SortType.NAME_ASC:
-            return "name";
+            return 'name';
         case SortType.NAME_DESC:
-            return "name:desc";
+            return 'name:desc';
         case SortType.PRICE_ASC:
-            return "price";
+            return 'price';
         case SortType.PRICE_DESC:
-            return "price:desc";
+            return 'price:desc';
         case SortType.NEWEST:
-            return "newest";
+            return 'newest';
         case SortType.RECOMMENDED:
-            return "recommended";
+            return 'recommended';
         default:
-            return "name";
+            return 'name';
     }
 }
 /**
  * Convert URL sort format to SortType enum
  */
 export function convertUrlSortToSortType(urlSort) {
-    const sortParts = urlSort.split(":");
+    const sortParts = urlSort.split(':');
     const field = sortParts[0]?.toLowerCase();
-    const order = sortParts[1]?.toLowerCase() === "desc" ? "desc" : "asc";
+    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":
+        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":
+        case 'recommended':
             return SortType.RECOMMENDED;
         default:
             return null;
@@ -62,7 +62,7 @@ export function convertUrlSortToSortType(urlSort) {
  * Update URL with current search state (sort, filters, pagination)
  */
 function updateUrlWithSearchState(searchState) {
-    if (typeof window === "undefined")
+    if (typeof window === 'undefined')
         return;
     const { sort, filters, customizations, catalogBounds, categorySlug } = searchState;
     // Convert filter IDs back to human-readable names for URL
@@ -86,14 +86,14 @@ function updateUrlWithSearchState(searchState) {
     const params = new URLSearchParams(window.location.search);
     // Define search-related parameters that we manage
     const searchParams = [
-        "sort",
-        "limit",
-        "cursor",
-        "minPrice",
-        "maxPrice",
-        "inventoryStatus",
-        "visible",
-        "productType",
+        '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
     ];
@@ -110,44 +110,44 @@ function updateUrlWithSearchState(searchState) {
     // Add sort parameter (only if not default)
     const urlSort = convertSortTypeToUrl(sort);
     if (sort !== SortType.NAME_ASC) {
-        params.set("sort", urlSort);
+        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());
+        params.set('minPrice', filters.priceRange.min.toString());
     }
     if (filters.priceRange?.max &&
         filters.priceRange.max < catalogBounds.maxPrice) {
-        params.set("maxPrice", filters.priceRange.max.toString());
+        params.set('maxPrice', filters.priceRange.max.toString());
     }
     // Add inventory status parameters
     if (filters.inventoryStatuses && filters.inventoryStatuses.length > 0) {
-        params.set("inventoryStatus", filters.inventoryStatuses.join(","));
+        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");
+        params.set('visible', 'false');
     }
     // Add product type filter
     if (filters.productType) {
-        params.set("productType", 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(","));
+            params.set(optionName, values.join(','));
         }
     }
     // Handle URL path construction with category
     let baseUrl = window.location.pathname;
     // If categorySlug is provided, replace the last path segment (which represents the category)
     if (categorySlug) {
-        const pathSegments = baseUrl.split("/").filter(Boolean);
+        const pathSegments = baseUrl.split('/').filter(Boolean);
         if (pathSegments.length > 0) {
             // Replace the last segment with the new category slug
             pathSegments[pathSegments.length - 1] = categorySlug;
-            baseUrl = "/" + pathSegments.join("/");
+            baseUrl = '/' + pathSegments.join('/');
         }
         else {
             // If no segments, just use the category slug
@@ -160,7 +160,7 @@ function updateUrlWithSearchState(searchState) {
         : baseUrl;
     // Only update if URL actually changed
     if (newUrl !== window.location.pathname + window.location.search) {
-        window.history.pushState(null, "", newUrl);
+        window.history.pushState(null, '', newUrl);
     }
 }
 /**
@@ -208,7 +208,7 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
     const initialSearchState = {};
     // Extract category slug from URL path
     // The category slug is always the last segment of the path
-    const pathSegments = urlObj.pathname.split("/").filter(Boolean);
+    const pathSegments = urlObj.pathname.split('/').filter(Boolean);
     let category = undefined;
     if (pathSegments.length > 0) {
         const lastSegment = pathSegments[pathSegments.length - 1];
@@ -219,14 +219,14 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
         }
     }
     // Handle text search (q parameter)
-    const query = searchParams.get("q");
+    const query = searchParams.get('q');
     if (query) {
         searchOptions.search = {
             expression: query,
         };
     }
     // Handle sorting
-    const sort = searchParams.get("sort");
+    const sort = searchParams.get('sort');
     if (sort) {
         const sortType = convertUrlSortToSortType(sort);
         if (sortType) {
@@ -235,18 +235,18 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
             switch (sortType) {
                 case SortType.NAME_ASC:
                     searchOptions.sort = [
-                        { fieldName: "name", order: productsV3.SortDirection.ASC },
+                        { fieldName: 'name', order: productsV3.SortDirection.ASC },
                     ];
                     break;
                 case SortType.NAME_DESC:
                     searchOptions.sort = [
-                        { fieldName: "name", order: productsV3.SortDirection.DESC },
+                        { fieldName: 'name', order: productsV3.SortDirection.DESC },
                     ];
                     break;
                 case SortType.PRICE_ASC:
                     searchOptions.sort = [
                         {
-                            fieldName: "actualPriceRange.minValue.amount",
+                            fieldName: 'actualPriceRange.minValue.amount',
                             order: productsV3.SortDirection.ASC,
                         },
                     ];
@@ -254,7 +254,7 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
                 case SortType.PRICE_DESC:
                     searchOptions.sort = [
                         {
-                            fieldName: "actualPriceRange.minValue.amount",
+                            fieldName: 'actualPriceRange.minValue.amount',
                             order: productsV3.SortDirection.DESC,
                         },
                     ];
@@ -262,7 +262,7 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
                 case SortType.RECOMMENDED:
                     searchOptions.sort = [
                         {
-                            fieldName: "name",
+                            fieldName: 'name',
                             order: productsV3.SortDirection.DESC,
                         },
                     ];
@@ -271,8 +271,8 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
         }
     }
     // Handle pagination
-    const limit = searchParams.get("limit");
-    const cursor = searchParams.get("cursor");
+    const limit = searchParams.get('limit');
+    const cursor = searchParams.get('cursor');
     if (limit || cursor) {
         searchOptions.cursorPaging = {};
         if (limit) {
@@ -289,54 +289,54 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
     }
     // Handle filtering for search options
     const filter = {};
-    const visible = searchParams.get("visible");
+    const visible = searchParams.get('visible');
     if (visible !== null) {
-        filter["visible"] = visible === "true";
-        initialSearchState.visible = visible === "true";
+        filter['visible'] = visible === 'true';
+        initialSearchState.visible = visible === 'true';
     }
-    const productType = searchParams.get("productType");
+    const productType = searchParams.get('productType');
     if (productType) {
-        filter["productType"] = productType;
+        filter['productType'] = productType;
         initialSearchState.productType = productType;
     }
     // Add category filter if found
     if (category) {
-        filter["allCategoriesInfo.categories"] = {
+        filter['allCategoriesInfo.categories'] = {
             $matchItems: [{ _id: { $in: [category._id] } }],
         };
     }
     // Price range filtering
-    const minPrice = searchParams.get("minPrice");
-    const maxPrice = searchParams.get("maxPrice");
+    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 };
+                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 };
+                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",
+        'minPrice',
+        'maxPrice',
+        'inventory_status',
+        'inventoryStatus',
+        'visible',
+        'productType',
+        'q',
+        'limit',
+        'cursor',
+        'sort',
     ];
     const productOptionsById = {};
     for (const [optionName, optionValues] of searchParams.entries()) {
@@ -347,7 +347,7 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
             c.customizationType ===
                 customizationsV3.CustomizationType.PRODUCT_OPTION);
         if (option && option._id) {
-            const choiceValues = optionValues.split(",").filter(Boolean);
+            const choiceValues = optionValues.split(',').filter(Boolean);
             const choiceIds = [];
             // Convert choice names to IDs
             for (const choiceName of choiceValues) {
@@ -375,20 +375,20 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
     // Add aggregations for getting filter options
     searchOptions.aggregations = [
         {
-            name: "minPrice",
-            fieldPath: "actualPriceRange.minValue.amount",
-            type: "SCALAR",
-            scalar: { type: "MIN" },
+            name: 'minPrice',
+            fieldPath: 'actualPriceRange.minValue.amount',
+            type: 'SCALAR',
+            scalar: { type: 'MIN' },
         },
         {
-            name: "maxPrice",
-            fieldPath: "actualPriceRange.maxValue.amount",
-            type: "SCALAR",
-            scalar: { type: "MAX" },
+            name: 'maxPrice',
+            fieldPath: 'actualPriceRange.maxValue.amount',
+            type: 'SCALAR',
+            scalar: { type: 'MAX' },
         },
         {
-            name: "optionNames",
-            fieldPath: "options.name",
+            name: 'optionNames',
+            fieldPath: 'options.name',
             type: productsV3.SortType.VALUE,
             value: {
                 limit: 20,
@@ -397,8 +397,8 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
             },
         },
         {
-            name: "choiceNames",
-            fieldPath: "options.choicesSettings.choices.name",
+            name: 'choiceNames',
+            fieldPath: 'options.choicesSettings.choices.name',
             type: productsV3.SortType.VALUE,
             value: {
                 limit: 50,
@@ -407,8 +407,8 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
             },
         },
         {
-            name: "inventoryStatus",
-            fieldPath: "inventory.availabilityStatus",
+            name: 'inventoryStatus',
+            fieldPath: 'inventory.availabilityStatus',
             type: productsV3.SortType.VALUE,
             value: {
                 limit: 10,
@@ -456,7 +456,7 @@ export async function parseUrlToSearchOptions(url, categoriesList, defaultSearch
  */
 export async function loadProductsListSearchServiceConfig(input) {
     let initialSearchState;
-    if (typeof input === "string") {
+    if (typeof input === 'string') {
         // URL input - parse it
         const categoriesListConfig = await loadCategoriesListServiceConfig();
         const { initialSearchState: parsedState } = await parseUrlToSearchOptions(input, categoriesListConfig.categories);
@@ -535,12 +535,12 @@ export const ProductsListSearchService = implementService.withConfig()(ProductsL
     });
     const hasPrevPageSignal = signalsService.computed(() => {
         const pagingMetadata = productsListService.pagingMetadata.get();
-        return typeof pagingMetadata.cursors?.prev !== "undefined";
+        return typeof pagingMetadata.cursors?.prev !== 'undefined';
     });
     // Debounce timeout IDs for price filters
     let minPriceTimeoutId = null;
     let maxPriceTimeoutId = null;
-    if (typeof window !== "undefined") {
+    if (typeof window !== 'undefined') {
         // Watch for changes in any search parameters and update search options
         signalsService.effect(() => {
             // Read all signals to establish dependencies
@@ -576,18 +576,18 @@ export const ProductsListSearchService = implementService.withConfig()(ProductsL
             switch (sort) {
                 case SortType.NAME_ASC:
                     newSearchOptions.sort = [
-                        { fieldName: "name", order: productsV3.SortDirection.ASC },
+                        { fieldName: 'name', order: productsV3.SortDirection.ASC },
                     ];
                     break;
                 case SortType.NAME_DESC:
                     newSearchOptions.sort = [
-                        { fieldName: "name", order: productsV3.SortDirection.DESC },
+                        { fieldName: 'name', order: productsV3.SortDirection.DESC },
                     ];
                     break;
                 case SortType.PRICE_ASC:
                     newSearchOptions.sort = [
                         {
-                            fieldName: "actualPriceRange.minValue.amount",
+                            fieldName: 'actualPriceRange.minValue.amount',
                             order: productsV3.SortDirection.ASC,
                         },
                     ];
@@ -595,7 +595,7 @@ export const ProductsListSearchService = implementService.withConfig()(ProductsL
                 case SortType.PRICE_DESC:
                     newSearchOptions.sort = [
                         {
-                            fieldName: "actualPriceRange.minValue.amount",
+                            fieldName: 'actualPriceRange.minValue.amount',
                             order: productsV3.SortDirection.DESC,
                         },
                     ];
@@ -603,7 +603,7 @@ export const ProductsListSearchService = implementService.withConfig()(ProductsL
                 case SortType.RECOMMENDED:
                     newSearchOptions.sort = [
                         {
-                            fieldName: "name",
+                            fieldName: 'name',
                             order: productsV3.SortDirection.DESC,
                         },
                     ];
@@ -617,32 +617,32 @@ export const ProductsListSearchService = implementService.withConfig()(ProductsL
                 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"];
+            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.")) {
+                if (key.startsWith('options.')) {
                     delete newSearchOptions.filter[key];
                 }
             });
             // Add new filters
             if (minPrice > 0) {
-                newSearchOptions.filter["actualPriceRange.minValue.amount"] = { $gte: minPrice };
+                newSearchOptions.filter['actualPriceRange.minValue.amount'] = { $gte: minPrice };
             }
             if (maxPrice > 0) {
-                newSearchOptions.filter["actualPriceRange.maxValue.amount"] = { $lte: maxPrice };
+                newSearchOptions.filter['actualPriceRange.maxValue.amount'] = { $lte: maxPrice };
             }
             if (selectedInventoryStatuses.length > 0) {
                 if (selectedInventoryStatuses.length === 1) {
-                    newSearchOptions.filter["inventory.availabilityStatus"] =
+                    newSearchOptions.filter['inventory.availabilityStatus'] =
                         selectedInventoryStatuses[0];
                 }
                 else {
-                    newSearchOptions.filter["inventory.availabilityStatus"] =
+                    newSearchOptions.filter['inventory.availabilityStatus'] =
                         { $in: selectedInventoryStatuses };
                 }
             }
@@ -653,19 +653,19 @@ export const ProductsListSearchService = implementService.withConfig()(ProductsL
                     allChoiceIds.push(...choiceIds);
                 }
                 if (allChoiceIds.length > 0) {
-                    newSearchOptions.filter["options.choicesSettings.choices.choiceId"] = { $hasSome: allChoiceIds };
+                    newSearchOptions.filter['options.choicesSettings.choices.choiceId'] = { $hasSome: allChoiceIds };
                 }
             }
             if (selectedCategory) {
-                newSearchOptions.filter["allCategoriesInfo.categories"] = {
+                newSearchOptions.filter['allCategoriesInfo.categories'] = {
                     $matchItems: [{ _id: { $in: [selectedCategory._id] } }],
                 };
             }
             if (selectedVisible !== null) {
-                newSearchOptions.filter["visible"] = selectedVisible;
+                newSearchOptions.filter['visible'] = selectedVisible;
             }
             if (selectedProductType) {
-                newSearchOptions.filter["productType"] =
+                newSearchOptions.filter['productType'] =
                     selectedProductType;
             }
             // Update the products list service
@@ -825,14 +825,14 @@ function getCatalogPriceRange(aggregationData) {
     return { minPrice, maxPrice };
 }
 function getMinPrice(aggregationData) {
-    const minPriceAggregation = aggregationData.find((data) => data.fieldPath === "actualPriceRange.minValue.amount");
+    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");
+    const maxPriceAggregation = aggregationData.find((data) => data.fieldPath === 'actualPriceRange.maxValue.amount');
     if (maxPriceAggregation?.scalar?.value) {
         return Number(maxPriceAggregation.scalar.value) || 0;
     }
@@ -859,15 +859,15 @@ function getAvailableProductOptions(aggregationData = [], customizations = []) {
     const optionNames = [];
     const choiceNames = [];
     aggregationData.forEach((result) => {
-        if (result.name === "optionNames" && result.values?.results) {
+        if (result.name === 'optionNames' && result.values?.results) {
             optionNames.push(...result.values.results
                 .map((item) => item.value)
-                .filter((value) => typeof value === "string"));
+                .filter((value) => typeof value === 'string'));
         }
-        if (result.name === "choiceNames" && result.values?.results) {
+        if (result.name === 'choiceNames' && result.values?.results) {
             choiceNames.push(...result.values.results
                 .map((item) => item.value)
-                .filter((value) => typeof value === "string"));
+                .filter((value) => typeof value === 'string'));
         }
     });
     const options = customizations

package/cjs/dist/services/products-list-service.d.ts

@@ -1,6 +1,6 @@
-import { type Signal } from "@wix/services-definitions/core-services/signals";
-import { productsV3 } from "@wix/stores";
-import { type InitialSearchState } from "./products-list-search-service.js";
+import { type Signal } from '@wix/services-definitions/core-services/signals';
+import { productsV3 } from '@wix/stores';
+import { type InitialSearchState } from './products-list-search-service.js';
 export declare const DEFAULT_QUERY_LIMIT = 100;
 /**
  * Configuration interface for the Products List service.
@@ -115,7 +115,7 @@ export type ProductsListServiceConfig = {
  * }
  * ```
  *
-  * @example
+ * @example
  * ```tsx
  * // Advanced: Performance optimization when using both services
  * import { parseUrlToSearchOptions, loadProductsListServiceConfig, loadProductsListSearchServiceConfig, loadCategoriesListServiceConfig } from '@wix/stores/services';

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

@@ -1,8 +1,8 @@
-import { defineService, implementService } from "@wix/services-definitions";
-import { SignalsServiceDefinition, } from "@wix/services-definitions/core-services/signals";
-import { productsV3, readOnlyVariantsV3 } from "@wix/stores";
-import { loadCategoriesListServiceConfig } from "./categories-list-service.js";
-import { parseUrlToSearchOptions } from "./products-list-search-service.js";
+import { defineService, implementService } from '@wix/services-definitions';
+import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
+import { productsV3, readOnlyVariantsV3 } from '@wix/stores';
+import { loadCategoriesListServiceConfig } from './categories-list-service.js';
+import { parseUrlToSearchOptions, } from './products-list-search-service.js';
 export const DEFAULT_QUERY_LIMIT = 100;
 /**
  * Loads products list service configuration from the Wix Stores API for SSR initialization.
@@ -101,7 +101,7 @@ export const DEFAULT_QUERY_LIMIT = 100;
  * }
  * ```
  *
-  * @example
+ * @example
  * ```tsx
  * // Advanced: Performance optimization when using both services
  * import { parseUrlToSearchOptions, loadProductsListServiceConfig, loadProductsListSearchServiceConfig, loadCategoriesListServiceConfig } from '@wix/stores/services';
@@ -183,7 +183,7 @@ const fetchMissingVariants = async (products) => {
         const items = [];
         const res = await readOnlyVariantsV3
             .queryVariants({})
-            .in("productData.productId", productIds)
+            .in('productData.productId', productIds)
             .limit(DEFAULT_QUERY_LIMIT)
             .find();
         items.push(...res.items);
@@ -207,7 +207,7 @@ const fetchMissingVariants = async (products) => {
         });
         // Update products with their variants
         return products.map((product) => {
-            const variants = variantsByProductId.get(product._id || "");
+            const variants = variantsByProductId.get(product._id || '');
             if (variants && variants.length > 0) {
                 return {
                     ...product,
@@ -221,7 +221,7 @@ const fetchMissingVariants = async (products) => {
         });
     }
     catch (error) {
-        console.error("Failed to fetch missing variants:", error);
+        console.error('Failed to fetch missing variants:', error);
         return products;
     }
 };
@@ -231,7 +231,7 @@ const fetchMissingVariants = async (products) => {
  *
  * @constant
  */
-export const ProductsListServiceDefinition = defineService("products-list");
+export const ProductsListServiceDefinition = defineService('products-list');
 /**
  * Implementation of the Products List service that manages reactive products data.
  * This service provides signals for products data, search options, pagination, aggregations,
@@ -295,7 +295,7 @@ export const ProductListService = implementService.withConfig()(ProductsListServ
     const aggregationsSignal = signalsService.signal(config.aggregations);
     const isLoadingSignal = signalsService.signal(false);
     const errorSignal = signalsService.signal(null);
-    if (typeof window !== "undefined") {
+    if (typeof window !== 'undefined') {
         signalsService.effect(async () => {
             // CRITICAL: Read the signals FIRST to establish dependencies, even on first run
             const searchOptions = searchOptionsSignal.get();
@@ -318,7 +318,7 @@ export const ProductListService = implementService.withConfig()(ProductsListServ
                 pagingMetadataSignal.set(result.pagingMetadata);
             }
             catch (error) {
-                errorSignal.set(error instanceof Error ? error.message : "Unknown error");
+                errorSignal.set(error instanceof Error ? error.message : 'Unknown error');
             }
             finally {
                 isLoadingSignal.set(false);