@wix/headless-stores 0.0.8 → 0.0.10

package/dist/services/product-media-gallery-service.js

@@ -0,0 +1,101 @@
+import { defineService, implementService, } from "@wix/services-definitions";
+import { SignalsServiceDefinition } from "@wix/services-definitions/core-services/signals";
+import { SelectedVariantServiceDefinition } from "./selected-variant-service";
+import { ProductServiceDefinition } from "./product-service";
+export const ProductMediaGalleryServiceDefinition = defineService("productMediaGallery");
+export const ProductMediaGalleryService = implementService.withConfig()(ProductMediaGalleryServiceDefinition, ({ getService }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const selectedVariantService = getService(SelectedVariantServiceDefinition);
+    const productService = getService(ProductServiceDefinition);
+    const selectedImageIndex = signalsService.signal(0);
+    const relevantImages = signalsService.computed(() => {
+        const product = productService.product.get();
+        const selectedChoices = selectedVariantService.selectedChoices?.get() || {};
+        // Get images based on selected choices if available
+        let selectedChoicesImages = [];
+        Object.keys(selectedChoices).forEach((choiceKey) => {
+            const productOption = product?.options?.find((option) => option.name === choiceKey)?.choicesSettings?.choices?.find((choice) => choice.name === selectedChoices[choiceKey]);
+            if (productOption) {
+                selectedChoicesImages.push(...(productOption?.linkedMedia?.map((media) => media.image) || []));
+            }
+        });
+        if (selectedChoicesImages?.length) {
+            return selectedChoicesImages;
+        }
+        const productItemsImages = product?.media?.itemsInfo?.items?.map((item) => item.image).filter(Boolean);
+        if (productItemsImages?.length) {
+            return productItemsImages;
+        }
+        if (product?.media?.main) {
+            return [product.media.main.image];
+        }
+        return [];
+    });
+    const product = productService.product;
+    const isLoading = productService.isLoading;
+    const totalImages = signalsService.computed(() => {
+        return relevantImages.get().length;
+    });
+    const productName = signalsService.computed(() => {
+        const prod = productService.product.get();
+        return prod?.name || "Product";
+    });
+    const subscribeToVariantChanges = () => {
+        return selectedVariantService.selectedChoices.subscribe(() => {
+            selectedImageIndex.set(0);
+        });
+    };
+    subscribeToVariantChanges();
+    const setSelectedImageIndex = (index) => {
+        const images = relevantImages.get();
+        if (!images.length)
+            return;
+        const maxIndex = images.length - 1;
+        const validIndex = Math.max(0, Math.min(index, maxIndex));
+        selectedImageIndex.set(validIndex);
+    };
+    const nextImage = () => {
+        const images = relevantImages.get();
+        const currentIndex = selectedImageIndex.get();
+        if (!images.length)
+            return;
+        const nextIndex = currentIndex >= images.length - 1
+            ? 0
+            : currentIndex + 1;
+        selectedImageIndex.set(nextIndex);
+    };
+    const previousImage = () => {
+        const images = relevantImages.get();
+        const currentIndex = selectedImageIndex.get();
+        if (!images.length)
+            return;
+        const prevIndex = currentIndex <= 0
+            ? images.length - 1
+            : currentIndex - 1;
+        selectedImageIndex.set(prevIndex);
+    };
+    return {
+        selectedImageIndex,
+        relevantImages,
+        setSelectedImageIndex,
+        nextImage,
+        previousImage,
+        product,
+        isLoading,
+        totalImages,
+        productName,
+    };
+});
+export async function loadProductMediaGalleryServiceConfig(
+// @ts-ignore
+productSlug) {
+    try {
+        // No need to fetch product data here since this service depends on ProductServiceDefinition
+        // which already loads the product data. We just need to return an empty config.
+        return {};
+    }
+    catch (error) {
+        console.error("Failed to load product media gallery config:", error);
+        throw error;
+    }
+}

package/dist/services/product-modifiers-service.d.ts

@@ -0,0 +1,36 @@
+import { type ServiceFactoryConfig } from "@wix/services-definitions";
+import type { Signal, ReadOnlySignal } from "./Signal";
+import { productsV3 } from "@wix/stores";
+export interface ModifierValue {
+    modifierName: string;
+    choiceValue?: string;
+    freeTextValue?: string;
+}
+export interface ProductModifiersServiceAPI {
+    modifiers: ReadOnlySignal<productsV3.ConnectedModifier[]>;
+    selectedModifiers: Signal<Record<string, ModifierValue>>;
+    hasModifiers: ReadOnlySignal<boolean>;
+    isLoading: Signal<boolean>;
+    error: Signal<string | null>;
+    setModifierChoice: (modifierName: string, choiceValue: string) => void;
+    setModifierFreeText: (modifierName: string, freeTextValue: string) => void;
+    clearModifier: (modifierName: string) => void;
+    clearAllModifiers: () => void;
+    getModifierValue: (modifierName: string) => ModifierValue | null;
+    isModifierRequired: (modifierName: string) => boolean;
+    hasRequiredModifiers: () => boolean;
+    areAllRequiredModifiersFilled: () => boolean;
+}
+export declare const ProductModifiersServiceDefinition: string & {
+    __api: ProductModifiersServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ProductModifiersServiceAPI;
+export declare const ProductModifiersService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: ProductModifiersServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ProductModifiersServiceAPI, {
+    product: productsV3.V3Product;
+}, import("@wix/services-definitions").ThreadMode.MAIN>;
+export declare function createProductModifiersServiceConfig(product: productsV3.V3Product): ServiceFactoryConfig<typeof ProductModifiersService>;

package/dist/services/product-modifiers-service.js

@@ -0,0 +1,100 @@
+import { defineService, implementService, } from "@wix/services-definitions";
+import { SignalsServiceDefinition } from "@wix/services-definitions/core-services/signals";
+export const ProductModifiersServiceDefinition = defineService("productModifiers");
+export const ProductModifiersService = implementService.withConfig()(ProductModifiersServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const configProduct = config.product;
+    const selectedModifiers = signalsService.signal({});
+    const isLoading = signalsService.signal(false);
+    const error = signalsService.signal(null);
+    // Extract modifiers from product
+    const modifiers = signalsService.computed(() => {
+        return (configProduct?.modifiers || []);
+    });
+    const hasModifiers = signalsService.computed(() => {
+        const mods = modifiers.get();
+        return mods.length > 0;
+    });
+    const setModifierChoice = (modifierName, choiceValue) => {
+        const current = selectedModifiers.get();
+        selectedModifiers.set({
+            ...current,
+            [modifierName]: {
+                modifierName,
+                choiceValue,
+            },
+        });
+    };
+    const setModifierFreeText = (modifierName, freeTextValue) => {
+        const current = selectedModifiers.get();
+        selectedModifiers.set({
+            ...current,
+            [modifierName]: {
+                modifierName,
+                freeTextValue,
+            },
+        });
+    };
+    const clearModifier = (modifierName) => {
+        const current = selectedModifiers.get();
+        const updated = { ...current };
+        delete updated[modifierName];
+        selectedModifiers.set(updated);
+    };
+    const clearAllModifiers = () => {
+        selectedModifiers.set({});
+    };
+    const getModifierValue = (modifierName) => {
+        const current = selectedModifiers.get();
+        return current[modifierName] || null;
+    };
+    const isModifierRequired = (modifierName) => {
+        const mods = modifiers.get();
+        const modifier = mods.find(m => m.name === modifierName);
+        return modifier?.mandatory || false;
+    };
+    const hasRequiredModifiers = () => {
+        const mods = modifiers.get();
+        return mods.some(m => m.mandatory);
+    };
+    const areAllRequiredModifiersFilled = () => {
+        const mods = modifiers.get();
+        const current = selectedModifiers.get();
+        return mods.every(modifier => {
+            if (!modifier.mandatory)
+                return true;
+            const selectedValue = current[modifier.name || ""];
+            if (!selectedValue)
+                return false;
+            // Check based on modifier type
+            const renderType = modifier.modifierRenderType;
+            if (renderType === "SWATCH_CHOICES" || renderType === "TEXT_CHOICES") {
+                return !!selectedValue.choiceValue;
+            }
+            else if (renderType === "FREE_TEXT") {
+                return !!selectedValue.freeTextValue && selectedValue.freeTextValue.trim() !== "";
+            }
+            return false;
+        });
+    };
+    return {
+        modifiers,
+        selectedModifiers,
+        hasModifiers,
+        isLoading,
+        error,
+        setModifierChoice,
+        setModifierFreeText,
+        clearModifier,
+        clearAllModifiers,
+        getModifierValue,
+        isModifierRequired,
+        hasRequiredModifiers,
+        areAllRequiredModifiersFilled,
+    };
+});
+export function createProductModifiersServiceConfig(product) {
+    return {
+        product,
+    };
+}

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

@@ -0,0 +1,27 @@
+import { type ServiceFactoryConfig } from "@wix/services-definitions";
+import type { Signal } from "./Signal";
+import { productsV3 } from "@wix/stores";
+export interface ProductServiceAPI {
+    product: Signal<productsV3.V3Product | null>;
+    isLoading: Signal<boolean>;
+    error: Signal<string | null>;
+}
+export declare const ProductServiceDefinition: string & {
+    __api: ProductServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ProductServiceAPI;
+export declare const ProductService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: ProductServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ProductServiceAPI, {
+    product: productsV3.V3Product;
+}, import("@wix/services-definitions").ThreadMode.MAIN>;
+export type ProductServiceConfigResult = {
+    type: "success";
+    config: ServiceFactoryConfig<typeof ProductService>;
+} | {
+    type: "notFound";
+};
+export declare function loadProductServiceConfig(productSlug: string): Promise<ProductServiceConfigResult>;

package/dist/services/product-service.js

@@ -0,0 +1,47 @@
+import { defineService, implementService, } from "@wix/services-definitions";
+import { SignalsServiceDefinition } from "@wix/services-definitions/core-services/signals";
+import { productsV3 } from "@wix/stores";
+export const ProductServiceDefinition = defineService("product");
+export const ProductService = implementService.withConfig()(ProductServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const product = signalsService.signal(config.product);
+    const isLoading = signalsService.signal(false);
+    const error = signalsService.signal(null);
+    return {
+        product,
+        isLoading,
+        error,
+    };
+});
+export async function loadProductServiceConfig(productSlug) {
+    try {
+        // Use getProductBySlug directly - single API call with comprehensive fields
+        const productResponse = await productsV3.getProductBySlug(productSlug, {
+            fields: [
+                "DESCRIPTION",
+                "DIRECT_CATEGORIES_INFO",
+                "BREADCRUMBS_INFO",
+                "INFO_SECTION",
+                "MEDIA_ITEMS_INFO",
+                "PLAIN_DESCRIPTION",
+                "THUMBNAIL",
+                "URL",
+                "VARIANT_OPTION_CHOICE_NAMES",
+                "WEIGHT_MEASUREMENT_UNIT_INFO",
+            ],
+        });
+        if (!productResponse.product) {
+            return { type: "notFound" };
+        }
+        return {
+            type: "success",
+            config: {
+                product: productResponse.product,
+            },
+        };
+    }
+    catch (error) {
+        console.error(`Failed to load product for slug "${productSlug}":`, error);
+        return { type: "notFound" };
+    }
+}

package/dist/services/related-products-service.d.ts

@@ -0,0 +1,25 @@
+import { type ServiceFactoryConfig } from "@wix/services-definitions";
+import type { Signal } from "./Signal";
+import { productsV3 } from "@wix/stores";
+export interface RelatedProductsServiceAPI {
+    relatedProducts: Signal<productsV3.V3Product[]>;
+    isLoading: Signal<boolean>;
+    error: Signal<string | null>;
+    hasRelatedProducts: Signal<boolean>;
+    loadRelatedProducts: (productId: string, limit?: number) => Promise<void>;
+    refreshRelatedProducts: () => Promise<void>;
+}
+export declare const RelatedProductsServiceDefinition: string & {
+    __api: RelatedProductsServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & RelatedProductsServiceAPI;
+export declare const RelatedProductsService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: RelatedProductsServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & RelatedProductsServiceAPI, {
+    productId: string;
+    limit?: number;
+}, import("@wix/services-definitions").ThreadMode.MAIN>;
+export declare function loadRelatedProductsServiceConfig(productId: string, limit?: number): Promise<ServiceFactoryConfig<typeof RelatedProductsService>>;

package/dist/services/related-products-service.js

@@ -0,0 +1,50 @@
+import { defineService, implementService, } from "@wix/services-definitions";
+import { SignalsServiceDefinition } from "@wix/services-definitions/core-services/signals";
+import { productsV3 } from "@wix/stores";
+export const RelatedProductsServiceDefinition = defineService("relatedProducts");
+export const RelatedProductsService = implementService.withConfig()(RelatedProductsServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const relatedProducts = signalsService.signal([]);
+    const isLoading = signalsService.signal(false);
+    const error = signalsService.signal(null);
+    const hasRelatedProducts = signalsService.signal(false);
+    const loadRelatedProducts = async (productId, limit = 4) => {
+        isLoading.set(true);
+        error.set(null);
+        try {
+            let relatedQuery = productsV3.queryProducts().ne("_id", productId);
+            const relatedResult = await relatedQuery.limit(limit).find();
+            relatedProducts.set(relatedResult.items || []);
+            hasRelatedProducts.set((relatedResult.items || []).length > 0);
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : "Failed to load related products";
+            error.set(errorMessage);
+            relatedProducts.set([]);
+            hasRelatedProducts.set(false);
+        }
+        finally {
+            isLoading.set(false);
+        }
+    };
+    const refreshRelatedProducts = async () => {
+        await loadRelatedProducts(config.productId, config.limit);
+    };
+    if (config.productId) {
+        loadRelatedProducts(config.productId, config.limit);
+    }
+    return {
+        relatedProducts,
+        isLoading,
+        error,
+        hasRelatedProducts,
+        loadRelatedProducts,
+        refreshRelatedProducts,
+    };
+});
+export async function loadRelatedProductsServiceConfig(productId, limit = 4) {
+    return {
+        productId,
+        limit,
+    };
+}

package/dist/services/selected-variant-service.d.ts

@@ -0,0 +1,51 @@
+import { type ServiceFactoryConfig } from "@wix/services-definitions";
+import type { Signal, ReadOnlySignal } from "./Signal";
+import { productsV3 } from "@wix/stores";
+export interface SelectedVariantServiceAPI {
+    selectedChoices: Signal<Record<string, string>>;
+    selectedVariantId: ReadOnlySignal<string | null>;
+    currentVariant: ReadOnlySignal<productsV3.Variant | null>;
+    currentPrice: ReadOnlySignal<string>;
+    currentCompareAtPrice: ReadOnlySignal<string | null>;
+    isInStock: ReadOnlySignal<boolean>;
+    isPreOrderEnabled: ReadOnlySignal<boolean>;
+    isLoading: Signal<boolean>;
+    error: Signal<string | null>;
+    variants: Signal<productsV3.Variant[]>;
+    options: Signal<Record<string, string[]>>;
+    basePrice: Signal<number>;
+    discountPrice: Signal<number | null>;
+    isOnSale: Signal<boolean | null>;
+    quantityAvailable: Signal<number>;
+    productId: Signal<string>;
+    sku: Signal<string>;
+    ribbonLabel: Signal<string | null>;
+    product: ReadOnlySignal<productsV3.V3Product | null>;
+    productOptions: ReadOnlySignal<productsV3.ConnectedOption[]>;
+    currency: ReadOnlySignal<string>;
+    selectedVariant: () => productsV3.Variant | null;
+    finalPrice: () => number;
+    isLowStock: (threshold?: number) => boolean;
+    setSelectedChoices: (choices: Record<string, string>) => void;
+    addToCart: (quantity?: number, modifiers?: Record<string, any>) => Promise<void>;
+    setOption: (group: string, value: string) => void;
+    selectVariantById: (id: string) => void;
+    loadProductVariants: (data: productsV3.Variant[]) => void;
+    resetSelections: () => void;
+    getAvailableChoicesForOption: (optionName: string) => string[];
+    isChoiceAvailable: (optionName: string, choiceValue: string) => boolean;
+    hasAnySelections: () => boolean;
+}
+export declare const SelectedVariantServiceDefinition: string & {
+    __api: SelectedVariantServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & SelectedVariantServiceAPI;
+export declare const SelectedVariantService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: SelectedVariantServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & SelectedVariantServiceAPI, {
+    product: productsV3.V3Product;
+}, import("@wix/services-definitions").ThreadMode.MAIN>;
+export declare function loadSelectedVariantServiceConfig(productSlug: string): Promise<ServiceFactoryConfig<typeof SelectedVariantService>>;