@wix/headless-stores 0.0.57 → 0.0.59

package/dist/react/core/ProductList.js

@@ -3,7 +3,7 @@ import { useService, WixServices } from '@wix/services-manager-react';
 import { createServicesMap } from '@wix/services-manager';
 import { ProductListService, ProductsListServiceDefinition, } from '../../services/products-list-service.js';
 import { ProductService, ProductServiceDefinition, } from '../../services/product-service.js';
-import { ProductsListSearchService, ProductsListSearchServiceDefinition, } from '../../services/products-list-search-service.js';
+import { CategoriesListService, CategoriesListServiceDefinition, } from '../../services/categories-list-service.js';
 /**
  * Root component that provides both ProductList and ProductListSearch service contexts to its children.
  * This component sets up the necessary services for managing products list state, including search,
@@ -64,8 +64,8 @@ import { ProductsListSearchService, ProductsListSearchServiceDefinition, } from
  */
 export function Root(props) {
     return (_jsx(WixServices, { servicesMap: createServicesMap()
-            .addService(ProductsListServiceDefinition, ProductListService, props.productsListConfig)
-            .addService(ProductsListSearchServiceDefinition, ProductsListSearchService, props.productsListSearchConfig), children: props.children }));
+            .addService(CategoriesListServiceDefinition, CategoriesListService, props.categoriesListConfig)
+            .addService(ProductsListServiceDefinition, ProductListService, props.productsListConfig), children: props.children }));
 }
 /**
  * Component that renders content when the products list is empty.

package/dist/react/core/ProductListFilters.d.ts

@@ -1,61 +1,6 @@
 import type { ReactNode } from 'react';
-import { type ProductOption, InventoryStatusType } from '../../services/products-list-search-service.js';
 import { Category } from '@wix/auto_sdk_categories_categories';
-/**
- * Props for InventoryStatus headless component
- */
-export interface InventoryStatusProps {
-    /** Content to display (can be a render function receiving inventory status controls or ReactNode) */
-    children: ((props: InventoryStatusRenderProps) => ReactNode) | ReactNode;
-}
-/**
- * Render props for InventoryStatus component
- */
-export interface InventoryStatusRenderProps {
-    /** Available inventory status options */
-    availableInventoryStatuses: InventoryStatusType[];
-    /** Currently selected inventory statuses */
-    selectedInventoryStatuses: InventoryStatusType[];
-    /** Function to toggle an inventory status filter */
-    toggleInventoryStatus: (status: InventoryStatusType) => void;
-}
-/**
- * Headless component for managing inventory status filters
- *
- * @component
- * @example
- * ```tsx
- * import { ProductList, ProductListFilters } from '@wix/stores/components';
- *
- * function InventoryStatusFilter() {
- *   return (
- *     <ProductList.Root
- *       productsListConfig={{ products: [], searchOptions: {}, pagingMetadata: {}, aggregations: {} }}
- *       productsListSearchConfig={{ customizations: [] }}
- *     >
- *       <ProductListFilters.InventoryStatus>
- *         {({ availableInventoryStatuses, selectedInventoryStatuses, toggleInventoryStatus }) => (
- *           <div>
- *             <h4>Inventory Status:</h4>
- *             {availableInventoryStatuses.map(status => (
- *               <label key={status}>
- *                 <input
- *                   type="checkbox"
- *                   checked={selectedInventoryStatuses.includes(status)}
- *                   onChange={() => toggleInventoryStatus(status)}
- *                 />
- *                 {status}
- *               </label>
- *             ))}
- *           </div>
- *         )}
- *       </ProductListFilters.InventoryStatus>
- *     </ProductList.Root>
- *   );
- * }
- * ```
- */
-export declare function InventoryStatus(props: InventoryStatusProps): ReactNode;
+import React from 'react';
 /**
  * Props for ResetTrigger headless component
  */
@@ -103,136 +48,19 @@ export interface ResetTriggerRenderProps {
  * ```
  */
 export declare function ResetTrigger(props: ResetTriggerProps): ReactNode;
-/**
- * Props for PriceRange headless component
- */
-export interface PriceRangeProps {
-    /** Content to display (can be a render function receiving price range controls or ReactNode) */
-    children: ((props: PriceRangeRenderProps) => ReactNode) | ReactNode;
-}
-/**
- * Render props for PriceRange component
- */
-export interface PriceRangeRenderProps {
-    /** Current minimum price filter value */
-    selectedMinPrice: number;
-    /** Current maximum price filter value */
-    selectedMaxPrice: number;
-    /** Catalog minimum price */
-    availableMinPrice: number;
-    /** Catalog maximum price */
-    availableMaxPrice: number;
-    /** Function to update the minimum price filter */
-    setSelectedMinPrice: (minPrice: number) => void;
-    /** Function to update the maximum price filter */
-    setSelectedMaxPrice: (maxPrice: number) => void;
-}
-/**
- * Headless component for managing price range filters (combined min/max)
- *
- * @component
- * @example
- * ```tsx
- * import { ProductList, ProductListFilters } from '@wix/stores/components';
- *
- * function PriceRangeFilter() {
- *   return (
- *     <ProductList.Root
- *       productsListConfig={{ products: [], searchOptions: {}, pagingMetadata: {}, aggregations: {} }}
- *       productsListSearchConfig={{ customizations: [] }}
- *     >
- *       <ProductListFilters.PriceRange>
- *         {({ minPrice, maxPrice, setSelectedMinPrice, setSelectedMaxPrice }) => (
- *           <div className="price-range">
- *             <h4>Price Range:</h4>
- *             <div className="price-inputs">
- *               <input
- *                 type="number"
- *                 value={minPrice}
- *                 onChange={(e) => setSelectedMinPrice(Number(e.target.value))}
- *                 placeholder="Min"
- *               />
- *               <span>to</span>
- *               <input
- *                 type="number"
- *                 value={maxPrice}
- *                 onChange={(e) => setSelectedMaxPrice(Number(e.target.value))}
- *                 placeholder="Max"
- *               />
- *             </div>
- *           </div>
- *         )}
- *       </ProductListFilters.PriceRange>
- *     </ProductList.Root>
- *   );
- * }
- * ```
- */
-export declare function PriceRange(props: PriceRangeProps): ReactNode;
 export interface CategoryFilterRenderProps {
     selectedCategory: Category | null;
-    setSelectedCategory: (category: Category | null) => void;
+    setSelectedCategory: (category: Category) => void;
 }
 export interface CategoryFilterProps {
     /** Content to display (can be a render function receiving category data or ReactNode) */
     children: ((props: CategoryFilterRenderProps) => ReactNode) | ReactNode;
 }
 export declare function CategoryFilter(props: CategoryFilterProps): ReactNode;
-/**
- * Props for ProductOptions headless component
- */
-export interface ProductOptionsProps {
-    /** Content to display (can be a render function receiving product option data or ReactNode) */
-    children: ((props: ProductOptionRenderProps) => ReactNode) | ReactNode;
+interface FilterProps {
+    children: ReactNode;
+    asChild?: boolean;
+    className?: string;
 }
-/**
- * Render props for ProductOption component
- */
-export interface ProductOptionRenderProps {
-    /** Product option data */
-    option: ProductOption;
-    /** Currently selected choice IDs for this option */
-    selectedChoices: string[];
-    /** Function to toggle a choice selection */
-    toggleChoice: (choiceId: string) => void;
-}
-/**
- * Headless component that renders content for each product option in the list.
- * Maps over all available product options and provides each option through a render prop.
- * Only renders when options are available (not loading, no error, and has options).
- * This follows the same collection pattern as ProductList.ItemContent and CategoryList.ItemContent.
- *
- * @component
- * @example
- * ```tsx
- * import { ProductList, ProductListFilters } from '@wix/stores/components';
- *
- * function ProductOptionsFilter() {
- *   return (
- *     <ProductList.Root
- *       productsListConfig={{ products: [], searchOptions: {}, pagingMetadata: {}, aggregations: {} }}
- *       productsListSearchConfig={{ customizations: [] }}
- *     >
- *       <ProductListFilters.ProductOptions>
- *         {({ option, selectedChoices, toggleChoice }) => (
- *           <div key={option.id}>
- *             <h4>{option.name}</h4>
- *             {option.choices.map(choice => (
- *               <label key={choice.id}>
- *                 <input
- *                   type="checkbox"
- *                   checked={selectedChoices.includes(choice.id)}
- *                   onChange={() => toggleChoice(choice.id)}
- *                 />
- *                 {choice.name}
- *               </label>
- *             ))}
- *           </div>
- *         )}
- *       </ProductListFilters.ProductOptions>
- *     </ProductList.Root>
- *   );
- * }
- * ```
- */
-export declare function ProductOptions(props: ProductOptionsProps): import("react/jsx-runtime").JSX.Element | null;
+export declare const Filter: React.ForwardRefExoticComponent<FilterProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/react/core/ProductListFilters.js

@@ -1,54 +1,71 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { useService } from '@wix/services-manager-react';
-import { ProductsListSearchServiceDefinition, } from '../../services/products-list-search-service.js';
-/**
- * Headless component for managing inventory status filters
- *
- * @component
- * @example
- * ```tsx
- * import { ProductList, ProductListFilters } from '@wix/stores/components';
- *
- * function InventoryStatusFilter() {
- *   return (
- *     <ProductList.Root
- *       productsListConfig={{ products: [], searchOptions: {}, pagingMetadata: {}, aggregations: {} }}
- *       productsListSearchConfig={{ customizations: [] }}
- *     >
- *       <ProductListFilters.InventoryStatus>
- *         {({ availableInventoryStatuses, selectedInventoryStatuses, toggleInventoryStatus }) => (
- *           <div>
- *             <h4>Inventory Status:</h4>
- *             {availableInventoryStatuses.map(status => (
- *               <label key={status}>
- *                 <input
- *                   type="checkbox"
- *                   checked={selectedInventoryStatuses.includes(status)}
- *                   onChange={() => toggleInventoryStatus(status)}
- *                 />
- *                 {status}
- *               </label>
- *             ))}
- *           </div>
- *         )}
- *       </ProductListFilters.InventoryStatus>
- *     </ProductList.Root>
- *   );
- * }
- * ```
- */
-export function InventoryStatus(props) {
-    const service = useService(ProductsListSearchServiceDefinition);
-    const availableInventoryStatuses = service.availableInventoryStatuses.get();
-    const selectedInventoryStatuses = service.selectedInventoryStatuses.get();
-    const toggleInventoryStatus = service.toggleInventoryStatus;
-    return typeof props.children === 'function'
-        ? props.children({
-            availableInventoryStatuses,
-            selectedInventoryStatuses,
-            toggleInventoryStatus,
-        })
-        : props.children;
+import { ProductsListServiceDefinition, InventoryStatusType, CategoriesListServiceDefinition, } from '../../services/index.js';
+import { useMemo } from 'react';
+import { Filter as FilterPrimitive, } from '@wix/headless-components/react';
+import { Slot } from '@radix-ui/react-slot';
+import React from 'react';
+// Conversion utilities for platform compatibility
+function getInventoryStatusLabel(status) {
+    switch (status) {
+        case InventoryStatusType.IN_STOCK:
+            return 'In Stock';
+        case InventoryStatusType.OUT_OF_STOCK:
+            return 'Out of Stock';
+        case InventoryStatusType.PARTIALLY_OUT_OF_STOCK:
+            return 'Limited Stock';
+        default:
+            return String(status);
+    }
+}
+function buildSearchFilterData(availableOptions, availableInventoryStatuses, availableMinPrice, availableMaxPrice) {
+    // Build consolidated filter options using search field names
+    const filterOptions = [
+        // Price range - use a logical key that maps to both min/max fields
+        {
+            key: 'priceRange',
+            label: 'Price Range',
+            type: 'range',
+            displayType: 'range',
+            validValues: [availableMinPrice, availableMaxPrice],
+            valueFormatter: (value) => `$${value}`,
+            fieldName: [
+                'actualPriceRange.minValue.amount',
+                'actualPriceRange.maxValue.amount',
+            ],
+        },
+        // Product options (colors, sizes, etc.) - individual filters for each option type
+        ...availableOptions.map((option) => ({
+            key: option.id,
+            label: String(option.name),
+            type: 'multi',
+            displayType: option.optionRenderType === 'SWATCH_CHOICES'
+                ? 'color'
+                : 'text',
+            fieldName: 'options.choicesSettings.choices.choiceId',
+            fieldType: 'array',
+            validValues: option.choices.map((choice) => choice.id),
+            valueFormatter: (value) => {
+                const choice = option.choices.find((c) => c.id === value);
+                const name = choice?.name || String(value);
+                return option.optionRenderType === 'SWATCH_CHOICES'
+                    ? name.toLowerCase()
+                    : name;
+            },
+        })),
+        // Inventory status - use actual search field name
+        {
+            key: 'inventory.availabilityStatus',
+            label: 'Availability',
+            type: 'multi',
+            displayType: 'text',
+            fieldName: 'inventory.availabilityStatus',
+            fieldType: 'singular',
+            validValues: availableInventoryStatuses,
+            valueFormatter: (value) => getInventoryStatusLabel(value),
+        },
+    ];
+    return { filterOptions };
 }
 /**
  * Headless component for resetting all filters
@@ -81,136 +98,85 @@ export function InventoryStatus(props) {
  * ```
  */
 export function ResetTrigger(props) {
-    const service = useService(ProductsListSearchServiceDefinition);
-    const resetFilters = service.reset;
-    const isFiltered = service.isFiltered.get();
+    const service = useService(ProductsListServiceDefinition);
+    const resetFilters = service.resetFilter;
+    const isFiltered = service.isFiltered().get();
     return typeof props.children === 'function'
         ? props.children({ resetFilters, isFiltered })
         : props.children;
 }
-/**
- * Headless component for managing price range filters (combined min/max)
- *
- * @component
- * @example
- * ```tsx
- * import { ProductList, ProductListFilters } from '@wix/stores/components';
- *
- * function PriceRangeFilter() {
- *   return (
- *     <ProductList.Root
- *       productsListConfig={{ products: [], searchOptions: {}, pagingMetadata: {}, aggregations: {} }}
- *       productsListSearchConfig={{ customizations: [] }}
- *     >
- *       <ProductListFilters.PriceRange>
- *         {({ minPrice, maxPrice, setSelectedMinPrice, setSelectedMaxPrice }) => (
- *           <div className="price-range">
- *             <h4>Price Range:</h4>
- *             <div className="price-inputs">
- *               <input
- *                 type="number"
- *                 value={minPrice}
- *                 onChange={(e) => setSelectedMinPrice(Number(e.target.value))}
- *                 placeholder="Min"
- *               />
- *               <span>to</span>
- *               <input
- *                 type="number"
- *                 value={maxPrice}
- *                 onChange={(e) => setSelectedMaxPrice(Number(e.target.value))}
- *                 placeholder="Max"
- *               />
- *             </div>
- *           </div>
- *         )}
- *       </ProductListFilters.PriceRange>
- *     </ProductList.Root>
- *   );
- * }
- * ```
- */
-export function PriceRange(props) {
-    const service = useService(ProductsListSearchServiceDefinition);
-    const selectedMinPrice = service.selectedMinPrice.get();
-    const selectedMaxPrice = service.selectedMaxPrice.get();
-    const availableMinPrice = service.availableMinPrice.get();
-    const availableMaxPrice = service.availableMaxPrice.get();
-    const setSelectedMinPrice = service.setSelectedMinPrice;
-    const setSelectedMaxPrice = service.setSelectedMaxPrice;
-    return typeof props.children === 'function'
-        ? props.children({
-            availableMinPrice,
-            selectedMinPrice,
-            selectedMaxPrice,
-            availableMaxPrice,
-            setSelectedMinPrice,
-            setSelectedMaxPrice,
-        })
-        : props.children;
-}
 export function CategoryFilter(props) {
-    const service = useService(ProductsListSearchServiceDefinition);
-    const selectedCategory = service.selectedCategory.get();
-    const setSelectedCategory = service.setSelectedCategory;
+    const categoriesService = useService(CategoriesListServiceDefinition);
+    const productListService = useService(ProductsListServiceDefinition);
+    const categories = categoriesService.categories.get();
+    const setSelectedCategory = (category) => {
+        const currentFilter = productListService.searchOptions.get().filter || {};
+        if (!category) {
+            delete currentFilter['allCategoriesInfo.categories'];
+            productListService.setFilter(currentFilter);
+            return;
+        }
+        productListService.setFilter({
+            ...currentFilter,
+            'allCategoriesInfo.categories': {
+                $matchItems: [{ id: { $in: [category._id] } }],
+            },
+        });
+    };
+    const selectedCategoryId = productListService.searchOptions.get().filter['allCategoriesInfo.categories']?.$matchItems?.[0]?.id
+        ?.$in?.[0];
+    const selectedCategory = categories?.find((c) => c._id === selectedCategoryId) || null;
     return typeof props.children === 'function'
         ? props.children({ selectedCategory, setSelectedCategory })
         : props.children;
 }
 /**
- * Headless component that renders content for each product option in the list.
- * Maps over all available product options and provides each option through a render prop.
- * Only renders when options are available (not loading, no error, and has options).
- * This follows the same collection pattern as ProductList.ItemContent and CategoryList.ItemContent.
- *
- * @component
- * @example
- * ```tsx
- * import { ProductList, ProductListFilters } from '@wix/stores/components';
- *
- * function ProductOptionsFilter() {
- *   return (
- *     <ProductList.Root
- *       productsListConfig={{ products: [], searchOptions: {}, pagingMetadata: {}, aggregations: {} }}
- *       productsListSearchConfig={{ customizations: [] }}
- *     >
- *       <ProductListFilters.ProductOptions>
- *         {({ option, selectedChoices, toggleChoice }) => (
- *           <div key={option.id}>
- *             <h4>{option.name}</h4>
- *             {option.choices.map(choice => (
- *               <label key={choice.id}>
- *                 <input
- *                   type="checkbox"
- *                   checked={selectedChoices.includes(choice.id)}
- *                   onChange={() => toggleChoice(choice.id)}
- *                 />
- *                 {choice.name}
- *               </label>
- *             ))}
- *           </div>
- *         )}
- *       </ProductListFilters.ProductOptions>
- *     </ProductList.Root>
- *   );
- * }
- * ```
+ * Internal component that provides filter data for the Filter component.
+ * Consolidates data from both search and list services.
  */
-export function ProductOptions(props) {
-    const service = useService(ProductsListSearchServiceDefinition);
-    const availableOptions = service.availableProductOptions.get();
-    const selectedProductOptions = service.selectedProductOptions.get();
-    // Don't render if no options are available
-    if (availableOptions.length === 0) {
-        return null;
-    }
-    // Map over options and create render prop for each
-    return (_jsx(_Fragment, { children: availableOptions.map((option) => {
-            const selectedChoices = selectedProductOptions[option.id] || [];
-            const toggleChoice = (choiceId) => {
-                service.toggleProductOption(option.id, choiceId);
-            };
-            return typeof props.children === 'function'
-                ? props.children({ option, selectedChoices, toggleChoice })
-                : props.children;
-        }) }));
+function AllFilters(props) {
+    const listService = useService(ProductsListServiceDefinition);
+    // Get current filter state
+    const currentSearchOptions = listService.searchOptions.get();
+    const currentFilter = currentSearchOptions.filter;
+    // Get available filter data
+    const availableOptions = listService.availableProductOptions.get();
+    const availableInventoryStatuses = listService.availableInventoryStatuses.get();
+    const availableMinPrice = listService.minPrice.get();
+    const availableMaxPrice = listService.maxPrice.get();
+    // Get filter state
+    const resetFilters = listService.resetFilter;
+    const isFiltered = listService.isFiltered().get();
+    // Build filter options and handlers
+    const searchFilterData = useMemo(() => {
+        const { filterOptions } = buildSearchFilterData(availableOptions, availableInventoryStatuses, availableMinPrice, availableMaxPrice);
+        const updateFilter = (newFilter) => {
+            listService.setFilter(newFilter);
+        };
+        return {
+            filterValue: currentFilter,
+            filterOptions,
+            updateFilter,
+            clearFilters: resetFilters,
+            hasFilters: isFiltered,
+        };
+    }, [
+        availableOptions,
+        availableInventoryStatuses,
+        availableMinPrice,
+        availableMaxPrice,
+        currentFilter,
+        resetFilters,
+        isFiltered,
+        listService,
+    ]);
+    return typeof props.children === 'function'
+        ? props.children({ searchFilter: searchFilterData })
+        : props.children;
 }
+export const Filter = React.forwardRef(({ children, className, asChild }, ref) => {
+    const Comp = asChild ? Slot : 'div';
+    return (_jsx(AllFilters, { children: ({ searchFilter }) => {
+            return (_jsx(FilterPrimitive.Root, { value: searchFilter.filterValue, onChange: searchFilter.updateFilter, filterOptions: searchFilter.filterOptions, children: _jsx(Comp, { className: className, ref: ref, children: children }) }));
+        } }));
+});