@wix/headless-stores 0.0.9 → 0.0.11

package/dist/services/selected-variant-service.js

@@ -0,0 +1,538 @@
+import { defineService, implementService } from '@wix/services-definitions';
+import { SignalsServiceDefinition } from '@wix/services-definitions/core-services/signals';
+import { ModifierRenderType, InventoryAvailabilityStatus, } from '@wix/auto_sdk_stores_products-v-3';
+import { queryInventoryItems } from '@wix/auto_sdk_stores_inventory-items-v-3';
+// import { CurrentCartServiceDefinition } from '../../ecom/services/current-cart-service';
+import { ProductServiceDefinition } from './product-service';
+export const SelectedVariantServiceDefinition = defineService('selectedVariant');
+export const SelectedVariantService = implementService.withConfig()(SelectedVariantServiceDefinition, ({ getService }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    // const cartService = getService(CurrentCartServiceDefinition);
+    const productService = getService(ProductServiceDefinition);
+    // const mediaService = getService(MediaGalleryServiceDefinition);
+    const selectedChoices = signalsService.signal({});
+    const preOrderMessage = signalsService.signal(null);
+    const initialProduct = productService.product.get();
+    signalsService.effect(() => {
+        const product = productService.product.get();
+        const selectedChoicesValue = selectedChoices.get() || {};
+        let mediaToDisplay = [];
+        const productItemsImages = product?.media?.itemsInfo?.items?.map(item => item).filter(Boolean) ??
+            [];
+        if (productItemsImages.length) {
+            mediaToDisplay = productItemsImages;
+        }
+        else if (product?.media?.main) {
+            mediaToDisplay = [product.media.main];
+        }
+        // Get images based on selected choices if available
+        let selectedChoicesImages = [];
+        Object.keys(selectedChoicesValue).forEach(choiceKey => {
+            const productOption = product?.options
+                ?.find((option) => option.name === choiceKey)
+                ?.choicesSettings?.choices?.find((choice) => choice.name === selectedChoicesValue[choiceKey]);
+            if (productOption) {
+                selectedChoicesImages.push(...(productOption.linkedMedia ?? []));
+            }
+        });
+        if (selectedChoicesImages?.length) {
+            mediaToDisplay = selectedChoicesImages;
+        }
+        console.log({ mediaToDisplay });
+        // mediaService.setMediaToDisplay(mediaToDisplay ?? []);
+    });
+    const parsePrice = (amount) => {
+        if (!amount)
+            return 0;
+        const parsed = parseFloat(amount);
+        return isNaN(parsed) ? 0 : parsed;
+    };
+    const processVariantChoices = (variant) => {
+        const choices = {};
+        if (variant.choices) {
+            for (const choice of variant.choices) {
+                if (choice.optionChoiceNames?.optionName &&
+                    choice.optionChoiceNames?.choiceName) {
+                    choices[choice.optionChoiceNames.optionName] =
+                        choice.optionChoiceNames.choiceName;
+                }
+            }
+        }
+        return choices;
+    };
+    const findVariantByChoices = (variants, selectedChoices) => {
+        return (variants.find(variant => {
+            const variantChoices = processVariantChoices(variant);
+            const choiceKeys = Object.keys(selectedChoices);
+            return choiceKeys.every(key => variantChoices[key] === selectedChoices[key]);
+        }) || null);
+    };
+    const findVariantWithMinPrice = () => {
+        const variantsList = variants.get();
+        const variantPrices = variantsList.map(x => Number(x.price?.actualPrice?.formattedAmount) ||
+            Number(x.price?.actualPrice?.amount));
+        const minPrice = String(Math.min(...variantPrices));
+        return variantsList.find(x => x.price?.actualPrice?.formattedAmount === minPrice ||
+            x.price?.actualPrice?.amount === minPrice);
+    };
+    const updateInventoryItemData = async (variantId, inStock, preOrderEnabled) => {
+        if (!variantId) {
+            preOrderMessage.set(null);
+            return;
+        }
+        try {
+            // Use the correct Wix inventoryItemsV3.queryInventoryItems() API
+            const queryResult = await queryInventoryItems()
+                .eq('variantId', variantId)
+                .find();
+            const inventoryItem = queryResult.items?.[0];
+            const isTrackingQuantity = inventoryItem?.trackQuantity ?? false;
+            trackQuantity.set(isTrackingQuantity);
+            preOrderMessage.set(inventoryItem?.preorderInfo?.message || null);
+            if (!inventoryItem || !isTrackingQuantity) {
+                quantityAvailable.set(null);
+                return;
+            }
+            if (inStock && inventoryItem?.quantity) {
+                quantityAvailable.set(inventoryItem.quantity);
+            }
+            else if (preOrderEnabled && inventoryItem.preorderInfo?.limit) {
+                quantityAvailable.set(inventoryItem.preorderInfo.limit);
+            }
+            else {
+                quantityAvailable.set(null);
+            }
+        }
+        catch (error) {
+            console.error('Failed to fetch inventory quantity:', error);
+            // Fallback on error
+            quantityAvailable.set(null);
+            trackQuantity.set(false);
+        }
+    };
+    const updateDataFromVariant = (variant) => {
+        if (variant) {
+            const inStock = variant.inventoryStatus?.inStock ?? true;
+            const preOrderEnabled = variant.inventoryStatus?.preorderEnabled ?? false;
+            // update the quantity available, tracking indication and pre-order message from the inventory API
+            updateInventoryItemData(variant._id, inStock, preOrderEnabled);
+        }
+        else {
+            quantityAvailable.set(0);
+            trackQuantity.set(false);
+        }
+    };
+    const isLoading = signalsService.signal(false);
+    const error = signalsService.signal(null);
+    const variants = signalsService.signal([]);
+    const options = signalsService.signal({});
+    const basePrice = signalsService.signal(0);
+    const discountPrice = signalsService.signal(null);
+    const isOnSale = signalsService.signal(null);
+    const quantityAvailable = signalsService.signal(null);
+    const trackQuantity = signalsService.signal(false);
+    const selectedQuantity = signalsService.signal(1);
+    const productId = signalsService.signal('');
+    const ribbonLabel = signalsService.signal(null);
+    const v3Product = signalsService.signal(initialProduct);
+    const init = (currentProduct) => {
+        if (currentProduct) {
+            v3Product.set(currentProduct);
+            productId.set(currentProduct._id || '');
+            ribbonLabel.set(currentProduct.ribbon?.name || null);
+            const actualPrice = currentProduct.actualPriceRange?.minValue?.amount;
+            const compareAtPrice = currentProduct.compareAtPriceRange?.minValue?.amount;
+            basePrice.set(parsePrice(actualPrice));
+            discountPrice.set(compareAtPrice ? parsePrice(compareAtPrice) : null);
+            isOnSale.set(!!compareAtPrice &&
+                parsePrice(compareAtPrice) > parsePrice(actualPrice));
+            if (currentProduct.options) {
+                const optionsMap = {};
+                currentProduct.options.forEach((option) => {
+                    if (option.name && option.choicesSettings?.choices) {
+                        optionsMap[option.name] = option.choicesSettings.choices.map((choice) => choice.name || '');
+                    }
+                });
+                options.set(optionsMap);
+            }
+            if (currentProduct.variantSummary.variantCount > 1) {
+                variants.set(currentProduct.variantsInfo?.variants || []);
+                if (currentProduct.variantsInfo?.variants?.length) {
+                    // updateDataFromVariant(currentProduct.variantsInfo?.variants[0]);
+                }
+            }
+            else {
+                const singleVariant = {
+                    _id: 'default',
+                    visible: true,
+                    choices: [],
+                    price: {
+                        actualPrice: currentProduct.actualPriceRange?.minValue,
+                        compareAtPrice: currentProduct.compareAtPriceRange?.minValue,
+                    },
+                    inventoryStatus: {
+                        inStock: currentProduct.inventory?.availabilityStatus ===
+                            InventoryAvailabilityStatus.IN_STOCK ||
+                            currentProduct.inventory?.availabilityStatus ===
+                                InventoryAvailabilityStatus.PARTIALLY_OUT_OF_STOCK,
+                        preorderEnabled: currentProduct.inventory?.preorderStatus === 'ENABLED',
+                    },
+                };
+                variants.set([singleVariant]);
+                updateDataFromVariant(singleVariant);
+            }
+        }
+    };
+    signalsService.effect(() => {
+        const currentProduct = productService.product.get();
+        init(currentProduct);
+    });
+    const currentVariant = signalsService.computed((() => {
+        const choices = selectedChoices.get();
+        const variantsList = variants.get();
+        if (!variantsList || variantsList.length === 0)
+            return null;
+        return (variantsList.find((variant) => {
+            const variantChoices = processVariantChoices(variant);
+            if (Object.keys(choices).length !== Object.keys(variantChoices).length)
+                return false;
+            return Object.entries(choices).every(([optionName, optionValue]) => {
+                return variantChoices[optionName] === optionValue;
+            });
+        }) || null);
+    }));
+    const selectedVariantId = signalsService.computed(() => {
+        const variant = currentVariant.get();
+        return variant?._id || null;
+    });
+    const variantWithMinPrice = findVariantWithMinPrice();
+    const currentPrice = signalsService.computed(() => {
+        const variant = currentVariant.get();
+        if (!variant && variantWithMinPrice) {
+            const formattedAmount = variantWithMinPrice?.price?.actualPrice?.formattedAmount;
+            if (formattedAmount) {
+                return formattedAmount;
+            }
+            const amount = variantWithMinPrice?.price?.actualPrice?.amount;
+            if (amount) {
+                return `$${amount}`;
+            }
+        }
+        const prod = v3Product.get();
+        // Try to get formatted amount first (if fields worked)
+        if (variant?.price?.actualPrice?.formattedAmount) {
+            return variant.price.actualPrice.formattedAmount;
+        }
+        if (prod?.actualPriceRange?.minValue?.formattedAmount) {
+            return prod.actualPriceRange.minValue.formattedAmount;
+        }
+        // Fallback: create our own formatted price from amount
+        let rawAmount = null;
+        if (variant?.price?.actualPrice?.amount) {
+            rawAmount = variant.price.actualPrice.amount;
+        }
+        else if (prod?.actualPriceRange?.minValue?.amount) {
+            rawAmount = prod.actualPriceRange.minValue.amount;
+        }
+        return rawAmount ? `$${rawAmount}` : '';
+    });
+    const currentCompareAtPrice = signalsService.computed(() => {
+        const variant = currentVariant.get();
+        const prod = v3Product.get();
+        if (!variant && variantWithMinPrice) {
+            const formattedAmount = variantWithMinPrice?.price?.compareAtPrice?.formattedAmount;
+            if (formattedAmount) {
+                return formattedAmount;
+            }
+            const amount = variantWithMinPrice?.price?.compareAtPrice?.amount;
+            if (amount) {
+                return `$${amount}`;
+            }
+        }
+        // Try to get formatted compare-at price first
+        if (variant?.price?.compareAtPrice?.formattedAmount) {
+            return variant.price.compareAtPrice.formattedAmount;
+        }
+        if (prod?.compareAtPriceRange?.minValue?.formattedAmount) {
+            return prod.compareAtPriceRange.minValue.formattedAmount;
+        }
+        // Fallback: create our own formatted price from amount
+        let rawAmount = null;
+        if (variant?.price?.compareAtPrice?.amount) {
+            rawAmount = variant.price.compareAtPrice.amount;
+        }
+        else if (prod?.compareAtPriceRange?.minValue?.amount) {
+            rawAmount = prod.compareAtPriceRange.minValue.amount;
+        }
+        return rawAmount ? `$${rawAmount}` : null;
+    });
+    const isInStock = signalsService.computed(() => {
+        const variant = currentVariant.get();
+        if (variant) {
+            return variant.inventoryStatus?.inStock ?? false;
+        }
+        else {
+            return false;
+        }
+    });
+    const isPreOrderEnabled = signalsService.computed(() => {
+        const variant = currentVariant.get();
+        return variant?.inventoryStatus?.preorderEnabled ?? false;
+    });
+    const product = v3Product;
+    const productOptions = signalsService.computed(() => {
+        const prod = v3Product.get();
+        return prod?.options || [];
+    });
+    const currency = signalsService.computed(() => {
+        const prod = v3Product.get();
+        return prod?.currency || 'USD';
+    });
+    const selectedVariant = () => {
+        const variantId = selectedVariantId.get();
+        const variantsList = variants.get();
+        return variantsList.find(v => v._id === variantId) || null;
+    };
+    const finalPrice = () => {
+        const discount = discountPrice.get();
+        const base = basePrice.get();
+        return discount !== null ? discount : base;
+    };
+    const isLowStock = () => {
+        // Note: Currently always returns false as inventory quantity tracking
+        // is handled separately by the inventory service
+        return false;
+    };
+    const setSelectedChoices = (choices) => {
+        selectedChoices.set(choices);
+        selectedQuantity.set(1); // Reset quantity when choices change
+        const matchingVariant = findVariantByChoices(variants.get(), choices);
+        updateDataFromVariant(matchingVariant);
+    };
+    const addToCart = async (_quantity = 1, modifiers) => {
+        try {
+            isLoading.set(true);
+            error.set(null);
+            const prod = v3Product.get();
+            const variant = currentVariant.get();
+            if (!prod?._id) {
+                throw new Error('Product not found');
+            }
+            // Build catalog reference with modifiers if provided
+            const catalogReference = {
+                catalogItemId: prod._id,
+                appId: '215238eb-22a5-4c36-9e7b-e7c08025e04e',
+                options: variant?._id && variant._id !== 'default'
+                    ? {
+                        variantId: variant._id,
+                        preOrderRequested: !!variant?.inventoryStatus?.preorderEnabled,
+                    }
+                    : undefined,
+            };
+            // Transform and add modifiers to catalog reference if they exist
+            if (modifiers && Object.keys(modifiers).length > 0) {
+                const options = {};
+                const customTextFields = {};
+                // Get product modifiers to determine types and keys
+                const productModifiers = prod.modifiers || [];
+                Object.values(modifiers).forEach((modifierValue) => {
+                    const modifierName = modifierValue.modifierName;
+                    const productModifier = productModifiers.find(m => m.name === modifierName);
+                    if (!productModifier)
+                        return;
+                    const renderType = productModifier.modifierRenderType;
+                    if (renderType === ModifierRenderType.TEXT_CHOICES ||
+                        renderType === ModifierRenderType.SWATCH_CHOICES) {
+                        // For choice modifiers, use the modifier key and choice value
+                        const modifierKey = productModifier.key || modifierName;
+                        if (modifierValue.choiceValue) {
+                            options[modifierKey] = modifierValue.choiceValue;
+                        }
+                    }
+                    else if (renderType === ModifierRenderType.FREE_TEXT) {
+                        // For free text modifiers, use the freeTextSettings key
+                        const freeTextKey = productModifier.freeTextSettings?.key || modifierName;
+                        if (modifierValue.freeTextValue) {
+                            customTextFields[freeTextKey] = modifierValue.freeTextValue;
+                        }
+                    }
+                });
+                // Add formatted modifiers to catalog reference
+                if (Object.keys(options).length > 0) {
+                    catalogReference.options = {
+                        ...catalogReference.options,
+                        options,
+                    };
+                }
+                if (Object.keys(customTextFields).length > 0) {
+                    catalogReference.options = {
+                        ...catalogReference.options,
+                        customTextFields,
+                    };
+                }
+            }
+            // const lineItems = [
+            //   {
+            //     catalogReference,
+            //     quantity,
+            //   },
+            // ];
+            // await cartService.addToCart(lineItems);
+        }
+        catch (err) {
+            error.set(err instanceof Error ? err.message : 'Failed to add to cart');
+        }
+        finally {
+            isLoading.set(false);
+        }
+    };
+    const setOption = (group, value) => {
+        const currentChoices = selectedChoices.get();
+        const newChoices = { ...currentChoices, [group]: value };
+        setSelectedChoices(newChoices);
+    };
+    const selectVariantById = (id) => {
+        const variantsList = variants.get();
+        const variant = variantsList.find(v => v._id === id);
+        if (variant) {
+            const variantChoices = processVariantChoices(variant);
+            selectedChoices.set(variantChoices);
+            updateDataFromVariant(variant);
+        }
+    };
+    const resetSelections = () => {
+        selectedChoices.set({});
+        selectedQuantity.set(1); // Reset quantity when resetting selections
+    };
+    // Quantity management methods
+    const setSelectedQuantity = (quantity) => {
+        const maxQuantity = quantityAvailable.get();
+        const validQuantity = Math.max(1, Math.min(quantity, maxQuantity || 999));
+        selectedQuantity.set(validQuantity);
+    };
+    const incrementQuantity = () => {
+        const current = selectedQuantity.get();
+        const maxQuantity = quantityAvailable.get();
+        const newQuantity = Math.min(current + 1, maxQuantity || 999);
+        selectedQuantity.set(newQuantity);
+    };
+    const decrementQuantity = () => {
+        const current = selectedQuantity.get();
+        const newQuantity = Math.max(1, current - 1);
+        selectedQuantity.set(newQuantity);
+    };
+    // New methods for smart variant selection
+    const getAvailableChoicesForOption = (optionName) => {
+        const currentChoices = selectedChoices.get();
+        const variantsList = variants.get();
+        // Get all possible choices for this option that result in valid variants
+        const availableChoices = new Set();
+        variantsList.forEach(variant => {
+            const variantChoices = processVariantChoices(variant);
+            // Check if this variant matches all currently selected choices (except for the option we're checking)
+            const matchesOtherChoices = Object.entries(currentChoices)
+                .filter(([key]) => key !== optionName)
+                .every(([key, value]) => variantChoices[key] === value);
+            if (matchesOtherChoices && variantChoices[optionName]) {
+                availableChoices.add(variantChoices[optionName]);
+            }
+        });
+        return Array.from(availableChoices);
+    };
+    // Core method that provides both availability and stock info efficiently
+    const getChoiceInfo = (optionName, choiceValue) => {
+        // Create hypothetical choices with this choice selected
+        const currentChoices = selectedChoices.get();
+        const hypotheticalChoices = {
+            ...currentChoices,
+            [optionName]: choiceValue,
+        };
+        // Get all variants and find one that matches these choices
+        const variantsList = variants.get();
+        const matchingVariants = variantsList.filter(variant => {
+            if (!variant.choices)
+                return false;
+            const variantChoices = {};
+            for (const choice of variant.choices) {
+                if (choice.optionChoiceNames?.optionName &&
+                    choice.optionChoiceNames?.choiceName) {
+                    variantChoices[choice.optionChoiceNames.optionName] =
+                        choice.optionChoiceNames.choiceName;
+                }
+            }
+            // Check if this variant matches our hypothetical choices
+            return Object.entries(hypotheticalChoices).every(([key, value]) => variantChoices[key] === value);
+        });
+        const isAvailable = matchingVariants.length > 0;
+        // Check if ANY of the matching variants are in stock
+        const isInStock = matchingVariants.some(variant => variant.inventoryStatus?.inStock === true);
+        // Check if ANY of the matching variants have pre-order enabled
+        const isPreOrderEnabled = matchingVariants.some(variant => variant.inventoryStatus?.preorderEnabled === true);
+        return { isAvailable, isInStock, isPreOrderEnabled };
+    };
+    // Simplified methods using the core getChoiceInfo
+    const isChoiceAvailable = (optionName, choiceValue) => {
+        return getChoiceInfo(optionName, choiceValue).isAvailable;
+    };
+    const isChoiceInStock = (optionName, choiceValue) => {
+        return getChoiceInfo(optionName, choiceValue).isInStock;
+    };
+    const isChoicePreOrderEnabled = (optionName, choiceValue) => {
+        return getChoiceInfo(optionName, choiceValue).isPreOrderEnabled;
+    };
+    const hasAnySelections = () => {
+        const currentChoices = selectedChoices.get();
+        return Object.keys(currentChoices).length > 0;
+    };
+    const IsAllVariantsAreOutOfStock = () => {
+        const variantsList = variants.get();
+        // All variants must be out of stock AND none should have preorder enabled
+        return (variantsList?.every(variant => !variant.inventoryStatus?.inStock &&
+            !variant.inventoryStatus?.preorderEnabled) ?? true);
+    };
+    return {
+        selectedChoices,
+        selectedVariantId,
+        currentVariant,
+        currentPrice,
+        currentCompareAtPrice,
+        isInStock,
+        isPreOrderEnabled,
+        preOrderMessage,
+        isLoading,
+        error,
+        variants,
+        options,
+        basePrice,
+        discountPrice,
+        isOnSale,
+        quantityAvailable,
+        trackQuantity,
+        selectedQuantity,
+        productId,
+        ribbonLabel,
+        setSelectedChoices,
+        addToCart,
+        setOption,
+        selectVariantById,
+        resetSelections,
+        // New methods for smart variant selection
+        getAvailableChoicesForOption,
+        getChoiceInfo,
+        isChoiceAvailable,
+        isChoiceInStock,
+        isChoicePreOrderEnabled,
+        hasAnySelections,
+        // Quantity management methods
+        setSelectedQuantity,
+        incrementQuantity,
+        decrementQuantity,
+        selectedVariant,
+        finalPrice,
+        isLowStock,
+        product,
+        productOptions,
+        currency,
+        IsAllVariantsAreOutOfStock,
+    };
+});

package/dist/services/social-sharing-service.d.ts

@@ -0,0 +1,41 @@
+import { type ServiceFactoryConfig } from '@wix/services-definitions';
+import type { Signal } from '../../Signal';
+export interface SharingPlatform {
+    name: string;
+    icon: string;
+    color: string;
+    shareUrl: string;
+}
+export interface SocialSharingServiceAPI {
+    availablePlatforms: Signal<SharingPlatform[]>;
+    shareCount: Signal<number>;
+    lastSharedPlatform: Signal<string | null>;
+    shareToFacebook: (url: string, title: string, description?: string) => void;
+    shareToTwitter: (url: string, text: string, hashtags?: string[]) => void;
+    shareToLinkedIn: (url: string, title: string, summary?: string) => void;
+    shareToWhatsApp: (url: string, text: string) => void;
+    shareToEmail: (url: string, subject: string, body: string) => void;
+    copyToClipboard: (url: string) => Promise<boolean>;
+    shareNative: (data: {
+        title: string;
+        text: string;
+        url: string;
+    }) => Promise<boolean>;
+    trackShare: (platform: string) => void;
+}
+export declare const SocialSharingServiceDefinition: string & {
+    __api: SocialSharingServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & SocialSharingServiceAPI;
+export declare const SocialSharingService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: SocialSharingServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & SocialSharingServiceAPI, {
+    productName: string;
+    productUrl: string;
+    productDescription?: string;
+    productImage?: string;
+}, import("@wix/services-definitions").ThreadMode.MAIN>;
+export declare function loadSocialSharingServiceConfig(productName: string, productUrl: string, productDescription?: string, productImage?: string): Promise<ServiceFactoryConfig<typeof SocialSharingService>>;