@wix/headless-stores 0.0.0

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

@@ -0,0 +1,66 @@
+import { type Signal, type ReadOnlySignal } from '@wix/services-definitions/core-services/signals';
+import * as productsV3 from '@wix/auto_sdk_stores_products-v-3';
+export interface SelectedVariantServiceAPI {
+    selectedQuantity: Signal<number>;
+    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>;
+    preOrderMessage: ReadOnlySignal<string | null>;
+    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 | null>;
+    trackQuantity: Signal<boolean>;
+    productId: 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: () => boolean;
+    setSelectedChoices: (choices: Record<string, string>) => void;
+    createLineItems: (quantity?: number, modifiers?: Record<string, any>) => Array<{
+        catalogReference: any;
+        quantity: number;
+    }>;
+    addToCart: (quantity?: number, modifiers?: Record<string, any>) => Promise<void>;
+    setOption: (group: string, value: string) => void;
+    setSelectedQuantity: (quantity: number) => void;
+    incrementQuantity: () => void;
+    decrementQuantity: () => void;
+    selectVariantById: (id: string) => void;
+    resetSelections: () => void;
+    getAvailableChoicesForOption: (optionName: string) => string[];
+    getChoiceInfo: (optionName: string, choiceValue: string) => {
+        isAvailable: boolean;
+        isInStock: boolean;
+        isPreOrderEnabled: boolean;
+    };
+    isChoiceAvailable: (optionName: string, choiceValue: string) => boolean;
+    isChoiceInStock: (optionName: string, choiceValue: string) => boolean;
+    isChoicePreOrderEnabled: (optionName: string, choiceValue: string) => boolean;
+    hasAnySelections: () => boolean;
+    IsAllVariantsAreOutOfStock: () => boolean;
+}
+export interface SelectedVariantServiceConfig {
+    fetchInventoryData?: 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, SelectedVariantServiceConfig>;

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

@@ -0,0 +1,527 @@
+import { defineService, implementService } from '@wix/services-definitions';
+import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
+import * as productsV3 from '@wix/auto_sdk_stores_products-v-3';
+import * as inventoryItemsV3 from '@wix/auto_sdk_stores_inventory-items-v-3';
+import { CurrentCartServiceDefinition } from '@wix/headless-ecom/services';
+import { MediaGalleryServiceDefinition } from '@wix/headless-media/services';
+import { ProductServiceDefinition } from './product-service.js';
+export const SelectedVariantServiceDefinition = defineService('selectedVariant');
+export const SelectedVariantService = implementService.withConfig()(SelectedVariantServiceDefinition, ({ getService, config: { fetchInventoryData = true } }) => {
+    const mediaService = getService(MediaGalleryServiceDefinition);
+    const signalsService = getService(SignalsServiceDefinition);
+    const cartService = getService(CurrentCartServiceDefinition);
+    const productService = getService(ProductServiceDefinition);
+    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;
+        }
+        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 updateInventoryItemData = async (variantId, inStock, preOrderEnabled) => {
+        if (!variantId) {
+            preOrderMessage.set(null);
+            return;
+        }
+        try {
+            // Use the correct Wix inventoryItemsV3.queryInventoryItems() API
+            const queryResult = await inventoryItemsV3
+                .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
+            // only if fetchInventoryData is enabled (defaults to true for backward compatibility)
+            if (fetchInventoryData) {
+                updateInventoryItemData(variant._id, inStock, preOrderEnabled);
+            }
+            else {
+                // Set default values when inventory fetching is disabled
+                quantityAvailable.set(null);
+                trackQuantity.set(false);
+                preOrderMessage.set(null);
+            }
+        }
+        else {
+            quantityAvailable.set(0);
+            trackQuantity.set(false);
+            preOrderMessage.set(null);
+        }
+    };
+    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 > 0) {
+                variants.set(currentProduct.variantsInfo?.variants || []);
+                if (currentProduct.variantsInfo?.variants?.length) {
+                    updateDataFromVariant(currentProduct.variantsInfo?.variants[0] || null);
+                }
+            }
+            else {
+                const singleVariant = {
+                    _id: 'default',
+                    visible: true,
+                    choices: [],
+                    price: {
+                        actualPrice: currentProduct.actualPriceRange?.minValue,
+                        compareAtPrice: currentProduct.compareAtPriceRange?.minValue,
+                    },
+                    inventoryStatus: {
+                        inStock: currentProduct.inventory?.availabilityStatus ===
+                            productsV3.InventoryAvailabilityStatus.IN_STOCK ||
+                            currentProduct.inventory?.availabilityStatus ===
+                                productsV3.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 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 !== '0' ? `$${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 createLineItems = (quantity = 1, modifiers) => {
+        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 === productsV3.ModifierRenderType.TEXT_CHOICES ||
+                    renderType === productsV3.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 === productsV3.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,
+                };
+            }
+        }
+        return [
+            {
+                catalogReference,
+                quantity,
+            },
+        ];
+    };
+    const addToCart = async (quantity = 1, modifiers) => {
+        try {
+            isLoading.set(true);
+            error.set(null);
+            const lineItems = createLineItems(quantity, modifiers);
+            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,
+        createLineItems,
+        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/cjs/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export declare function getCheckoutUrlForProduct(productId: string, variantId?: string): Promise<string>;

package/cjs/dist/utils/index.js

@@ -0,0 +1,30 @@
+import { checkout } from '@wix/ecom';
+import { redirects } from '@wix/redirects';
+const CATLOG_APP_ID_V3 = '215238eb-22a5-4c36-9e7b-e7c08025e04e';
+export async function getCheckoutUrlForProduct(productId, variantId) {
+    const checkoutResult = await checkout.createCheckout({
+        lineItems: [
+            {
+                catalogReference: {
+                    catalogItemId: productId,
+                    appId: CATLOG_APP_ID_V3,
+                    options: {
+                        variantId,
+                    },
+                },
+                quantity: 1,
+            },
+        ],
+        channelType: checkout.ChannelType.WEB,
+    });
+    if (!checkoutResult._id) {
+        throw new Error('Failed to create checkout');
+    }
+    const { redirectSession } = await redirects.createRedirectSession({
+        ecomCheckout: { checkoutId: checkoutResult._id },
+        callbacks: {
+            postFlowUrl: window.location.href,
+        },
+    });
+    return redirectSession?.fullUrl;
+}