@wix/headless-stores 0.0.9 → 0.0.10

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

@@ -0,0 +1,392 @@
+import { defineService, implementService, } from "@wix/services-definitions";
+import { SignalsServiceDefinition } from "@wix/services-definitions/core-services/signals";
+import { productsV3 } from "@wix/stores";
+export const SelectedVariantServiceDefinition = defineService("selectedVariant");
+export const SelectedVariantService = implementService.withConfig()(SelectedVariantServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    // const cartService = getService(CurrentCartServiceDefinition);
+    const configProduct = config.product;
+    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 getDefaultVariant = (): productsV3.Variant | null => {
+    //   const variantsList = variants.get();
+    //   return variantsList[0] || null;
+    // };
+    const updateQuantityFromVariant = (variant) => {
+        if (variant) {
+            const inStock = variant.inventoryStatus?.inStock ?? true;
+            const preOrderEnabled = variant.inventoryStatus?.preorderEnabled ?? false;
+            // If in stock, allow 999. If out of stock but pre-order enabled, allow 999. Otherwise 0.
+            quantityAvailable.set(inStock || preOrderEnabled ? 999 : 0);
+        }
+        else {
+            quantityAvailable.set(0);
+        }
+    };
+    const selectedChoices = signalsService.signal({});
+    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(0);
+    const productId = signalsService.signal("");
+    const sku = signalsService.signal("");
+    const ribbonLabel = signalsService.signal(null);
+    const v3Product = signalsService.signal(configProduct);
+    if (configProduct) {
+        productId.set(configProduct._id || "");
+        ribbonLabel.set(configProduct.ribbon?.name || null);
+        const actualPrice = configProduct.actualPriceRange?.minValue?.amount;
+        const compareAtPrice = configProduct.compareAtPriceRange?.minValue?.amount;
+        basePrice.set(parsePrice(actualPrice));
+        discountPrice.set(compareAtPrice ? parsePrice(compareAtPrice) : null);
+        isOnSale.set(!!compareAtPrice && parsePrice(compareAtPrice) > parsePrice(actualPrice));
+        if (configProduct.options) {
+            const optionsMap = {};
+            configProduct.options.forEach((option) => {
+                if (option.name && option.choicesSettings?.choices) {
+                    optionsMap[option.name] = option.choicesSettings.choices.map((choice) => choice.name || "");
+                }
+            });
+            options.set(optionsMap);
+        }
+        if (configProduct.variantsInfo?.variants) {
+            variants.set(configProduct.variantsInfo.variants);
+            if (configProduct.variantsInfo.variants.length > 0) {
+                updateQuantityFromVariant(configProduct.variantsInfo.variants[0] || null);
+            }
+        }
+        else {
+            const singleVariant = {
+                _id: "default",
+                visible: true,
+                choices: [],
+                price: {
+                    actualPrice: configProduct.actualPriceRange?.minValue,
+                    compareAtPrice: configProduct.compareAtPriceRange?.minValue,
+                },
+                inventoryStatus: {
+                    inStock: configProduct.inventory?.availabilityStatus === "IN_STOCK" ||
+                        configProduct.inventory?.availabilityStatus ===
+                            "PARTIALLY_OUT_OF_STOCK",
+                    preorderEnabled: configProduct.inventory?.preorderStatus === "ENABLED",
+                },
+            };
+            variants.set([singleVariant]);
+            updateQuantityFromVariant(singleVariant);
+        }
+    }
+    const currentVariant = signalsService.computed((() => {
+        const prod = v3Product.get();
+        const choices = selectedChoices.get();
+        if (!prod?.variantsInfo?.variants)
+            return null;
+        return (prod.variantsInfo.variants.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 currentPrice = signalsService.computed(() => {
+        const variant = currentVariant.get();
+        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();
+        // 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;
+    };
+    // @ts-ignore
+    const isLowStock = (threshold = 5) => {
+        return false;
+    };
+    const setSelectedChoices = (choices) => {
+        selectedChoices.set(choices);
+        const matchingVariant = findVariantByChoices(variants.get(), choices);
+        updateQuantityFromVariant(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 ? { 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 === "TEXT_CHOICES" ||
+                        renderType === "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 === "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,
+                    };
+                }
+            }
+            // @ts-ignore
+            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);
+            updateQuantityFromVariant(variant);
+        }
+    };
+    const loadProductVariants = (data) => {
+        variants.set(data);
+        if (data.length > 0) {
+            updateQuantityFromVariant(data[0] || null);
+        }
+    };
+    const resetSelections = () => {
+        selectedChoices.set({});
+    };
+    // 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);
+    };
+    const isChoiceAvailable = (optionName, choiceValue) => {
+        const availableChoices = getAvailableChoicesForOption(optionName);
+        return availableChoices.includes(choiceValue);
+    };
+    const hasAnySelections = () => {
+        const currentChoices = selectedChoices.get();
+        return Object.keys(currentChoices).length > 0;
+    };
+    return {
+        selectedChoices,
+        selectedVariantId,
+        currentVariant,
+        currentPrice,
+        currentCompareAtPrice,
+        isInStock,
+        isPreOrderEnabled,
+        isLoading,
+        error,
+        variants,
+        options,
+        basePrice,
+        discountPrice,
+        isOnSale,
+        quantityAvailable,
+        productId,
+        sku,
+        ribbonLabel,
+        setSelectedChoices,
+        addToCart,
+        setOption,
+        selectVariantById,
+        loadProductVariants,
+        resetSelections,
+        // New methods for smart variant selection
+        getAvailableChoicesForOption,
+        isChoiceAvailable,
+        hasAnySelections,
+        selectedVariant,
+        finalPrice,
+        isLowStock,
+        product,
+        productOptions,
+        currency,
+    };
+});
+export async function loadSelectedVariantServiceConfig(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) {
+            throw new Error("Product not found");
+        }
+        return {
+            product: productResponse.product,
+        };
+    }
+    catch (error) {
+        console.error(`Failed to load product for slug "${productSlug}":`, error);
+        throw error;
+    }
+}

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>>;

package/dist/services/social-sharing-service.js

@@ -0,0 +1,153 @@
+import { defineService, implementService, } from "@wix/services-definitions";
+import { SignalsServiceDefinition } from "@wix/services-definitions/core-services/signals";
+export const SocialSharingServiceDefinition = defineService("socialSharing");
+export const SocialSharingService = implementService.withConfig()(SocialSharingServiceDefinition, ({ getService }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const availablePlatforms = signalsService.signal([
+        {
+            name: "Facebook",
+            icon: "facebook",
+            color: "#1877F2",
+            shareUrl: "https://www.facebook.com/sharer/sharer.php",
+        },
+        {
+            name: "Twitter",
+            icon: "twitter",
+            color: "#1DA1F2",
+            shareUrl: "https://twitter.com/intent/tweet",
+        },
+        {
+            name: "LinkedIn",
+            icon: "linkedin",
+            color: "#0A66C2",
+            shareUrl: "https://www.linkedin.com/sharing/share-offsite/",
+        },
+        {
+            name: "WhatsApp",
+            icon: "whatsapp",
+            color: "#25D366",
+            shareUrl: "https://wa.me/",
+        },
+        {
+            name: "Email",
+            icon: "mail",
+            color: "#EA4335",
+            shareUrl: "mailto:",
+        },
+    ]);
+    const shareCount = signalsService.signal(0);
+    const lastSharedPlatform = signalsService.signal(null);
+    const openShareWindow = (url, platform) => {
+        const width = 600;
+        const height = 400;
+        const left = (window.screen.width - width) / 2;
+        const top = (window.screen.height - height) / 2;
+        window.open(url, `share-${platform}`, `width=${width},height=${height},left=${left},top=${top},scrollbars=yes,resizable=yes`);
+        trackShare(platform);
+    };
+    const shareToFacebook = (url, title, description) => {
+        const shareUrl = new URL("https://www.facebook.com/sharer/sharer.php");
+        shareUrl.searchParams.set("u", url);
+        shareUrl.searchParams.set("quote", `${title}${description ? ` - ${description}` : ""}`);
+        openShareWindow(shareUrl.toString(), "facebook");
+    };
+    const shareToTwitter = (url, text, hashtags) => {
+        const shareUrl = new URL("https://twitter.com/intent/tweet");
+        shareUrl.searchParams.set("url", url);
+        shareUrl.searchParams.set("text", text);
+        if (hashtags && hashtags.length > 0) {
+            shareUrl.searchParams.set("hashtags", hashtags.join(","));
+        }
+        openShareWindow(shareUrl.toString(), "twitter");
+    };
+    const shareToLinkedIn = (url, title, summary) => {
+        const shareUrl = new URL("https://www.linkedin.com/sharing/share-offsite/");
+        shareUrl.searchParams.set("url", url);
+        shareUrl.searchParams.set("title", title);
+        if (summary) {
+            shareUrl.searchParams.set("summary", summary);
+        }
+        openShareWindow(shareUrl.toString(), "linkedin");
+    };
+    const shareToWhatsApp = (url, text) => {
+        const message = `${text} ${url}`;
+        const shareUrl = `https://wa.me/?text=${encodeURIComponent(message)}`;
+        openShareWindow(shareUrl, "whatsapp");
+    };
+    const shareToEmail = (url, subject, body) => {
+        const emailBody = `${body}\n\n${url}`;
+        const mailtoUrl = `mailto:?subject=${encodeURIComponent(subject)}&body=${encodeURIComponent(emailBody)}`;
+        window.location.href = mailtoUrl;
+        trackShare("email");
+    };
+    const copyToClipboard = async (url) => {
+        try {
+            if (navigator.clipboard && window.isSecureContext) {
+                await navigator.clipboard.writeText(url);
+                trackShare("clipboard");
+                return true;
+            }
+            else {
+                const textArea = document.createElement("textarea");
+                textArea.value = url;
+                textArea.style.position = "fixed";
+                textArea.style.left = "-999999px";
+                textArea.style.top = "-999999px";
+                document.body.appendChild(textArea);
+                textArea.focus();
+                textArea.select();
+                const success = document.execCommand("copy");
+                textArea.remove();
+                if (success) {
+                    trackShare("clipboard");
+                }
+                return success;
+            }
+        }
+        catch (err) {
+            console.error("Failed to copy to clipboard:", err);
+            return false;
+        }
+    };
+    const shareNative = async (data) => {
+        try {
+            if (navigator.share) {
+                await navigator.share(data);
+                trackShare("native");
+                return true;
+            }
+            return false;
+        }
+        catch (err) {
+            console.error("Failed to share natively:", err);
+            return false;
+        }
+    };
+    const trackShare = (platform) => {
+        const currentCount = shareCount.get();
+        shareCount.set(currentCount + 1);
+        lastSharedPlatform.set(platform);
+        console.log(`Shared to ${platform} - Total shares: ${currentCount + 1}`);
+    };
+    return {
+        availablePlatforms,
+        shareCount,
+        lastSharedPlatform,
+        shareToFacebook,
+        shareToTwitter,
+        shareToLinkedIn,
+        shareToWhatsApp,
+        shareToEmail,
+        copyToClipboard,
+        shareNative,
+        trackShare,
+    };
+});
+export async function loadSocialSharingServiceConfig(productName, productUrl, productDescription, productImage) {
+    return {
+        productName,
+        productUrl,
+        productDescription,
+        productImage,
+    };
+}

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

@@ -0,0 +1,19 @@
+import type { Signal } from "./Signal";
+export type SortBy = "" | "name-asc" | "name-desc" | "price-asc" | "price-desc";
+export interface SortServiceAPI {
+    currentSort: Signal<SortBy>;
+    setSortBy: (sortBy: SortBy) => Promise<void>;
+}
+export declare const SortServiceDefinition: string & {
+    __api: SortServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & SortServiceAPI;
+export declare const defaultSort: SortBy;
+export declare const SortService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: SortServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & SortServiceAPI, {
+    initialSort?: SortBy;
+}, import("@wix/services-definitions").ThreadMode.MAIN>;

package/dist/services/sort-service.js

@@ -0,0 +1,34 @@
+import { defineService, implementService } from "@wix/services-definitions";
+import { SignalsServiceDefinition } from "@wix/services-definitions/core-services/signals";
+import { URLParamsUtils } from "../utils/url-params";
+export const SortServiceDefinition = defineService("sort");
+export const defaultSort = "";
+export const SortService = implementService.withConfig()(SortServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const currentSort = signalsService.signal((config.initialSort || defaultSort));
+    const setSortBy = async (sortBy) => {
+        currentSort.set(sortBy);
+        // Update URL with sort parameter
+        const currentParams = URLParamsUtils.getURLParams();
+        const sortMap = {
+            "name-asc": "name_asc",
+            "name-desc": "name_desc",
+            "price-asc": "price_asc",
+            "price-desc": "price_desc",
+            "": "newest",
+        };
+        const sortParam = sortMap[sortBy] || "newest";
+        const urlParams = { ...currentParams };
+        if (sortParam !== "newest") {
+            urlParams["sort"] = sortParam;
+        }
+        else {
+            delete urlParams["sort"];
+        }
+        URLParamsUtils.updateURL(urlParams);
+    };
+    return {
+        currentSort,
+        setSortBy,
+    };
+});

package/dist/utils/url-params.d.ts

@@ -0,0 +1,5 @@
+export declare class URLParamsUtils {
+    static parseSearchParams(searchParams: URLSearchParams): Record<string, string | string[]>;
+    static updateURL(params: Record<string, string | string[]>): void;
+    static getURLParams(): Record<string, string | string[]>;
+}