@wix/headless-stores 0.0.8 → 0.0.10

package/dist/react/index.d.ts

@@ -1,2 +1,12 @@
 export * from "./BuyNow";
 export * from "./PayNow";
+export * as Sort from "./Sort";
+export * as Category from "./Category";
+export * as FilteredCollection from "./FilteredCollection";
+export * as ProductVariantSelector from "./ProductVariantSelector";
+export * as RelatedProducts from "./RelatedProducts";
+export * as SocialSharing from "./SocialSharing";
+export * as Collection from "./Collection";
+export * as Product from "./Product";
+export * as ProductMediaGallery from "./ProductMediaGallery";
+export * as ProductModifiers from "./ProductModifiers";

package/dist/react/index.js

@@ -1,2 +1,12 @@
 export * from "./BuyNow";
 export * from "./PayNow";
+export * as Sort from "./Sort";
+export * as Category from "./Category";
+export * as FilteredCollection from "./FilteredCollection";
+export * as ProductVariantSelector from "./ProductVariantSelector";
+export * as RelatedProducts from "./RelatedProducts";
+export * as SocialSharing from "./SocialSharing";
+export * as Collection from "./Collection";
+export * as Product from "./Product";
+export * as ProductMediaGallery from "./ProductMediaGallery";
+export * as ProductModifiers from "./ProductModifiers";

package/dist/services/catalog-options-service.d.ts

@@ -0,0 +1,30 @@
+import { type ServiceFactoryConfig } from "@wix/services-definitions";
+import type { Signal } from "./Signal";
+export interface ProductOption {
+    id: string;
+    name: string;
+    choices: ProductChoice[];
+    optionRenderType?: string;
+}
+export interface ProductChoice {
+    id: string;
+    name: string;
+    colorCode?: string;
+}
+export interface CatalogOptionsServiceAPI {
+    catalogOptions: Signal<ProductOption[] | null>;
+    isLoading: Signal<boolean>;
+    error: Signal<string | null>;
+    loadCatalogOptions: (categoryId?: string) => Promise<void>;
+}
+export declare const CatalogOptionsServiceDefinition: string & {
+    __api: CatalogOptionsServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & CatalogOptionsServiceAPI;
+export declare const CatalogOptionsService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: CatalogOptionsServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & CatalogOptionsServiceAPI, {}, import("@wix/services-definitions").ThreadMode.MAIN>;
+export declare function loadCatalogOptionsServiceConfig(): Promise<ServiceFactoryConfig<typeof CatalogOptionsService>>;

package/dist/services/catalog-options-service.js

@@ -0,0 +1,158 @@
+import { defineService, implementService, } from "@wix/services-definitions";
+import { SignalsServiceDefinition } from "@wix/services-definitions/core-services/signals";
+import { productsV3, customizationsV3 } from "@wix/stores";
+// Helper functions
+const extractAggregationValues = (aggregationResponse, name) => {
+    const aggregation = aggregationResponse.aggregations?.[name] ||
+        aggregationResponse.aggregationData?.results?.find((r) => r.name === name);
+    return aggregation?.values?.results?.map((item) => item.value) || [];
+};
+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(b.name) - parseInt(a.name);
+        }
+        if (aIsNumber && !bIsNumber)
+            return -1;
+        if (!aIsNumber && bIsNumber)
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+};
+const buildCategoryFilter = (categoryId) => {
+    if (!categoryId) {
+        return { visible: true };
+    }
+    return {
+        visible: true,
+        "allCategoriesInfo.categories": {
+            $matchItems: [{ _id: { $in: [categoryId] } }],
+        },
+    };
+};
+export const CatalogOptionsServiceDefinition = defineService("catalogOptions");
+export const CatalogOptionsService = implementService.withConfig()(CatalogOptionsServiceDefinition, ({ getService }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const catalogOptions = signalsService.signal(null);
+    const isLoading = signalsService.signal(false);
+    const error = signalsService.signal(null);
+    const loadCatalogOptions = async (categoryId) => {
+        isLoading.set(true);
+        error.set(null);
+        try {
+            // Step 1: Get unique option and choice names from catalog via aggregation (no products returned)
+            const aggregationRequest = {
+                aggregations: [
+                    {
+                        name: "optionNames",
+                        fieldPath: "options.name",
+                        type: "VALUE",
+                        value: {
+                            limit: 20,
+                            sortType: "VALUE",
+                            sortDirection: "ASC",
+                        },
+                    },
+                    {
+                        name: "choiceNames",
+                        fieldPath: "options.choicesSettings.choices.name",
+                        type: "VALUE",
+                        value: {
+                            limit: 50,
+                            sortType: "VALUE",
+                            sortDirection: "ASC",
+                        },
+                    },
+                    {
+                        name: "inventoryStatus",
+                        fieldPath: "inventory.availabilityStatus",
+                        type: "VALUE",
+                        value: {
+                            limit: 10,
+                            sortType: "VALUE",
+                            sortDirection: "ASC",
+                        },
+                    },
+                ],
+                filter: buildCategoryFilter(categoryId),
+                includeProducts: false,
+                cursorPaging: { limit: 0 },
+            };
+            const aggregationResponse = await productsV3.searchProducts(aggregationRequest);
+            const optionNames = extractAggregationValues(aggregationResponse, "optionNames");
+            const choiceNames = extractAggregationValues(aggregationResponse, "choiceNames");
+            const inventoryStatuses = extractAggregationValues(aggregationResponse, "inventoryStatus");
+            // Step 2: Get option structure from customizations API
+            const customizationsResponse = await customizationsV3
+                .queryCustomizations()
+                .find();
+            const customizations = customizationsResponse.items || [];
+            // Step 3: Build options by matching customizations with aggregation data
+            const options = customizations
+                .filter((customization) => customization.name &&
+                customization._id &&
+                customization.customizationType === "PRODUCT_OPTION" &&
+                matchesAggregationName(customization.name, optionNames))
+                .map((customization) => {
+                const choices = (customization.choicesSettings?.choices || [])
+                    .filter((choice) => choice._id &&
+                    choice.name &&
+                    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);
+            // Step 4: Add inventory filter if there are multiple inventory statuses
+            if (inventoryStatuses.length > 1) {
+                const inventoryChoices = inventoryStatuses.map((status) => ({
+                    id: status.toUpperCase(), // Use uppercase to match actual availabilityStatus values
+                    name: status.toUpperCase() === "IN_STOCK"
+                        ? "In Stock"
+                        : status.toUpperCase() === "OUT_OF_STOCK"
+                            ? "Out of Stock"
+                            : status.toUpperCase() === "PARTIALLY_OUT_OF_STOCK"
+                                ? "Partially out of stock"
+                                : status,
+                }));
+                options.push({
+                    id: "inventory-filter",
+                    name: "Availability",
+                    choices: inventoryChoices,
+                    optionRenderType: "TEXT_CHOICES",
+                });
+            }
+            catalogOptions.set(options);
+        }
+        catch (err) {
+            console.error("Failed to load catalog options:", err);
+            error.set(err instanceof Error ? err.message : "Failed to load catalog options");
+            catalogOptions.set([]);
+        }
+        finally {
+            isLoading.set(false);
+        }
+    };
+    return {
+        catalogOptions,
+        isLoading,
+        error,
+        loadCatalogOptions,
+    };
+});
+export async function loadCatalogOptionsServiceConfig() {
+    return {};
+}

package/dist/services/catalog-price-range-service.d.ts

@@ -0,0 +1,23 @@
+import { type ServiceFactoryConfig } from "@wix/services-definitions";
+import type { Signal } from "./Signal";
+export interface CatalogPriceRange {
+    minPrice: number;
+    maxPrice: number;
+}
+export interface CatalogPriceRangeServiceAPI {
+    catalogPriceRange: Signal<CatalogPriceRange | null>;
+    isLoading: Signal<boolean>;
+    error: Signal<string | null>;
+    loadCatalogPriceRange: (categoryId?: string) => Promise<void>;
+}
+export declare const CatalogPriceRangeServiceDefinition: string & {
+    __api: CatalogPriceRangeServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & CatalogPriceRangeServiceAPI;
+export declare const CatalogPriceRangeService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: CatalogPriceRangeServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & CatalogPriceRangeServiceAPI, {}, import("@wix/services-definitions").ThreadMode.MAIN>;
+export declare function loadCatalogPriceRangeServiceConfig(): Promise<ServiceFactoryConfig<typeof CatalogPriceRangeService>>;

package/dist/services/catalog-price-range-service.js

@@ -0,0 +1,91 @@
+import { defineService, implementService, } from "@wix/services-definitions";
+import { SignalsServiceDefinition } from "@wix/services-definitions/core-services/signals";
+import { productsV3 } from "@wix/stores";
+// Helper function to extract scalar aggregation values
+const extractScalarAggregationValue = (aggregationResponse, name) => {
+    const aggregation = aggregationResponse.aggregations?.[name] ||
+        aggregationResponse.aggregationData?.results?.find((r) => r.name === name);
+    const value = aggregation?.scalar?.value;
+    return value !== undefined && value !== null ? parseFloat(value) : null;
+};
+const buildCategoryFilter = (categoryId) => {
+    if (!categoryId) {
+        return { visible: true };
+    }
+    return {
+        visible: true,
+        'allCategoriesInfo.categories': {
+            $matchItems: [{ _id: { $in: [categoryId] } }]
+        }
+    };
+};
+export const CatalogPriceRangeServiceDefinition = defineService("catalogPriceRange");
+export const CatalogPriceRangeService = implementService.withConfig()(CatalogPriceRangeServiceDefinition, ({ getService }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    // Signal declarations
+    const catalogPriceRange = signalsService.signal(null);
+    const isLoading = signalsService.signal(false);
+    const error = signalsService.signal(null);
+    /**
+     * Load the catalog-wide price range using a single aggregation query
+     * This fetches min/max prices from ALL products in the catalog using SCALAR aggregations
+     */
+    const loadCatalogPriceRange = async (categoryId) => {
+        isLoading.set(true);
+        error.set(null);
+        try {
+            // Single aggregation request to get both min and max prices (no products returned)
+            const aggregationRequest = {
+                aggregations: [
+                    {
+                        name: 'minPrice',
+                        fieldPath: 'actualPriceRange.minValue.amount',
+                        type: 'SCALAR',
+                        scalar: { type: 'MIN' }
+                    },
+                    {
+                        name: 'maxPrice',
+                        fieldPath: 'actualPriceRange.maxValue.amount',
+                        type: 'SCALAR',
+                        scalar: { type: 'MAX' }
+                    }
+                ],
+                filter: buildCategoryFilter(categoryId),
+                includeProducts: false,
+                cursorPaging: { limit: 0 }
+            };
+            const aggregationResponse = await productsV3.searchProducts(aggregationRequest);
+            const minPrice = extractScalarAggregationValue(aggregationResponse, 'minPrice');
+            const maxPrice = extractScalarAggregationValue(aggregationResponse, 'maxPrice');
+            // Only set price range if we found valid prices
+            if (minPrice !== null && maxPrice !== null && (minPrice > 0 || maxPrice > 0)) {
+                catalogPriceRange.set({
+                    minPrice,
+                    maxPrice
+                });
+            }
+            else {
+                // No products found or no valid prices - don't show the filter
+                catalogPriceRange.set(null);
+            }
+        }
+        catch (err) {
+            console.error('Failed to load catalog price range:', err);
+            error.set(err instanceof Error ? err.message : 'Failed to load price range');
+            // Don't set fallback values - let the component handle the error state
+            catalogPriceRange.set(null);
+        }
+        finally {
+            isLoading.set(false);
+        }
+    };
+    return {
+        catalogPriceRange,
+        isLoading,
+        error,
+        loadCatalogPriceRange,
+    };
+});
+export async function loadCatalogPriceRangeServiceConfig() {
+    return {};
+}

package/dist/services/category-service.d.ts

@@ -0,0 +1,25 @@
+import type { Signal } from "./Signal";
+import { categories } from "@wix/categories";
+export interface CategoryServiceAPI {
+    selectedCategory: Signal<string | null>;
+    categories: Signal<categories.Category[]>;
+    setSelectedCategory: (categoryId: string | null) => void;
+}
+export declare const CategoryServiceDefinition: string & {
+    __api: CategoryServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & CategoryServiceAPI;
+export interface CategoryServiceConfig {
+    categories: categories.Category[];
+    initialCategoryId?: string | null;
+    onCategoryChange?: (categoryId: string | null, category: categories.Category | null) => void;
+}
+export declare const CategoryService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: CategoryServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & CategoryServiceAPI, CategoryServiceConfig, import("@wix/services-definitions").ThreadMode.MAIN>;
+export declare function loadCategoriesConfig(): Promise<{
+    categories: categories.Category[];
+}>;

package/dist/services/category-service.js

@@ -0,0 +1,63 @@
+import { defineService, implementService } from "@wix/services-definitions";
+import { SignalsServiceDefinition } from "@wix/services-definitions/core-services/signals";
+import { categories } from "@wix/categories";
+export const CategoryServiceDefinition = defineService("category-service");
+export const CategoryService = implementService.withConfig()(CategoryServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const selectedCategory = signalsService.signal((config.initialCategoryId || null));
+    const categories = signalsService.signal(config.categories);
+    // Track if this is the initial load to prevent navigation on service creation
+    let isInitialLoad = true;
+    const setSelectedCategory = (categoryId) => {
+        selectedCategory.set(categoryId);
+    };
+    // Subscribe to category changes and handle navigation as a side effect
+    selectedCategory.subscribe((categoryId) => {
+        // Skip navigation on initial load (when service is first created)
+        if (isInitialLoad) {
+            isInitialLoad = false;
+            return;
+        }
+        // If a navigation handler is provided, use it
+        if (config.onCategoryChange) {
+            const category = categoryId
+                ? config.categories.find((cat) => cat._id === categoryId) || null
+                : null;
+            config.onCategoryChange(categoryId, category);
+        }
+    });
+    return {
+        selectedCategory,
+        categories,
+        setSelectedCategory,
+    };
+});
+export async function loadCategoriesConfig() {
+    try {
+        const categoriesResponse = await categories
+            .queryCategories({
+            treeReference: {
+                appNamespace: "@wix/stores",
+                treeKey: null,
+            },
+        })
+            .eq("visible", true)
+            .find();
+        const fetchedCategories = categoriesResponse.items || [];
+        // Sort categories to put "all-products" first, keep the rest in original order
+        const allProductsCategory = fetchedCategories.find(cat => cat.slug === "all-products");
+        const otherCategories = fetchedCategories.filter(cat => cat.slug !== "all-products");
+        const allCategories = allProductsCategory
+            ? [allProductsCategory, ...otherCategories]
+            : fetchedCategories;
+        return {
+            categories: allCategories,
+        };
+    }
+    catch (error) {
+        console.warn("Failed to load categories:", error);
+        return {
+            categories: [],
+        };
+    }
+}

package/dist/services/collection-service.d.ts

@@ -0,0 +1,37 @@
+import { type ServiceFactoryConfig } from "@wix/services-definitions";
+import type { Signal } from "./Signal";
+import { productsV3 } from "@wix/stores";
+import { type Filter } from "./filter-service";
+import { type SortBy } from "./sort-service";
+export interface CollectionServiceAPI {
+    products: Signal<productsV3.V3Product[]>;
+    isLoading: Signal<boolean>;
+    error: Signal<string | null>;
+    totalProducts: Signal<number>;
+    hasProducts: Signal<boolean>;
+    hasMoreProducts: Signal<boolean>;
+    loadMore: () => Promise<void>;
+    refresh: () => Promise<void>;
+}
+export declare const CollectionServiceDefinition: string & {
+    __api: CollectionServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & CollectionServiceAPI;
+export declare const CollectionService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: CollectionServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & CollectionServiceAPI, {
+    initialProducts?: productsV3.V3Product[];
+    pageSize?: number;
+    initialCursor?: string;
+    initialHasMore?: boolean;
+    categories?: any[];
+}, import("@wix/services-definitions").ThreadMode.MAIN>;
+export declare function loadCollectionServiceConfig(categoryId?: string, searchParams?: URLSearchParams): Promise<ServiceFactoryConfig<typeof CollectionService> & {
+    initialCursor?: string;
+    initialHasMore?: boolean;
+    initialSort?: SortBy;
+    initialFilters?: Filter;
+}>;