@weareconceptstudio/cart 0.0.1

package/dist/store/cartStore.js

@@ -0,0 +1,663 @@
+/**
+ * Cart Store - Zustand Implementation
+ * Enhanced with all features from old Context implementation
+ */
+import { create } from 'zustand';
+import { devtools } from 'zustand/middleware';
+import { api, getCookie, setCookie, removeCookie, isNumeric } from '@weareconceptstudio/core';
+import { addOrUpdateItem, removeItem, cleanObject, parseCookieCart, serializeCartToCookie, } from '../utils/helpers';
+// Initial state
+const initialCartState = {
+    items: [],
+    itemsCount: 0,
+    subtotal: 0,
+    formatted_subtotal: '0',
+    total: 0,
+    formatted_total: '0',
+    currency: 'AMD',
+    shippingCost: '-',
+    formatted_shippingCost: '-',
+    shippingCostValue: null,
+    shippingCityName: null,
+    discount: null,
+    formatted_discount: null,
+    remaining: null,
+    formatted_remaining: null,
+    hasFreeGift: null,
+    giftThresholdRemaining: null,
+    formatted_giftThresholdRemaining: null,
+    appliedPromotions: [],
+    loading: true,
+    useBalance: null,
+    formatted_useBalance: null,
+    promotion_code: null,
+    promotion_error: null,
+    utensils: [],
+};
+// Helper to load checkout data from session storage
+const loadCheckoutDataFromSession = () => {
+    if (typeof sessionStorage !== 'undefined') {
+        try {
+            const stored = sessionStorage.getItem('checkoutData');
+            if (stored) {
+                return JSON.parse(stored);
+            }
+        }
+        catch (error) {
+            console.error('Error loading checkout data from session:', error);
+        }
+    }
+    return {
+        addressId: null,
+        billingAddressId: null,
+        shippingAddressId: null,
+        useBalance: null,
+        note: '',
+        paymentType: 'cash_on_delivery',
+        gifts: [],
+        card_id: null,
+        excludedPromotions: [],
+        promotion_code: null,
+        promotion_error: null,
+        utensils: [],
+    };
+};
+const initialCheckoutData = loadCheckoutDataFromSession();
+// Helper to save checkout data to session storage
+const saveCheckoutDataToSession = (data) => {
+    if (typeof sessionStorage !== 'undefined') {
+        try {
+            sessionStorage.setItem('checkoutData', JSON.stringify(data));
+        }
+        catch (error) {
+            console.error('Error saving checkout data to session:', error);
+        }
+    }
+};
+// Helper to get cart resource type based on current page
+const getCartResourceType = () => {
+    if (typeof window === 'undefined')
+        return 'cart-summary';
+    const href = window.location.href;
+    return href.includes('checkout') || href.includes('cart') ? 'cart' : 'cart-summary';
+};
+/**
+ * Create cart store
+ */
+export const useCartStore = create()(devtools((set, get) => ({
+    ...initialCartState,
+    config: { hasVariants: false },
+    checkoutData: initialCheckoutData,
+    isLoggedIn: false,
+    selectedLang: 'en',
+    user: null,
+    idramFormData: null,
+    isCheckoutPage: false,
+    isCartPage: false,
+    /**
+     * Set loading state
+     */
+    setLoading: (loading) => {
+        set({ loading }, false, 'cart/setLoading');
+    },
+    /**
+     * Set user (for card validation, etc.)
+     */
+    setUser: (user) => {
+        set({ user }, false, 'cart/setUser');
+    },
+    /**
+     * Get cart from server
+     */
+    getCart: async (params = {}) => {
+        const { config, isLoggedIn, selectedLang, checkoutData } = get();
+        const cartResourceType = getCartResourceType();
+        try {
+            // set({ loading: true }, false, 'cart/getCart/start');
+            const requestParams = config.hasVariants
+                ? { ...params, cartResourceType }
+                : { ...cleanObject(checkoutData), ...params, cartResourceType };
+            if (isLoggedIn) {
+                // Logged in user - fetch from server
+                const { data } = await api.get({
+                    url: 'cart',
+                    lang: selectedLang,
+                    params: requestParams,
+                });
+                set({
+                    ...data,
+                    itemsCount: data.itemsCount ?? data.items_qty ?? 0,
+                    items: data.items ?? [],
+                    useBalance: data.useBalance || null,
+                    promotion_code: data.promotion_code || null,
+                    promotion_error: data.promotion_error || null,
+                    loading: false,
+                }, false, 'cart/getCart/success');
+                // Auto-sync checkout data
+                get().updateCheckoutData({
+                    useBalance: data.useBalance || null,
+                    promotion_code: data.promotion_code || null,
+                    promotion_error: data.promotion_error || null,
+                });
+            }
+            else {
+                // Guest user - use cookies
+                const cookieItems = parseCookieCart(getCookie('cart'));
+                if (cookieItems.length === 0) {
+                    set({ ...initialCartState, loading: false }, false, 'cart/getCart/empty');
+                    return;
+                }
+                const payload = config.hasVariants
+                    ? { cart: cookieItems, cartResourceType }
+                    : { items: cookieItems, ...requestParams };
+                const { data } = await api.post('guest-cart', payload, selectedLang);
+                set({
+                    ...data,
+                    itemsCount: data.itemsCount ?? data.items_qty ?? 0,
+                    items: data.items ?? [],
+                    useBalance: data.useBalance || null,
+                    promotion_code: data.promotion_code || null,
+                    promotion_error: data.promotion_error || null,
+                    loading: false,
+                }, false, 'cart/getCart/success');
+                // Auto-sync checkout data
+                get().updateCheckoutData({
+                    useBalance: data.useBalance || null,
+                    promotion_code: data.promotion_code || null,
+                    promotion_error: data.promotion_error || null,
+                });
+            }
+        }
+        catch (error) {
+            console.error('Error fetching cart:', error);
+            set({ loading: false }, false, 'cart/getCart/error');
+        }
+    },
+    /**
+     * Add item to cart
+     */
+    addItem: async (params) => {
+        const { config, isLoggedIn, selectedLang, checkoutData } = get();
+        const cartResourceType = getCartResourceType();
+        try {
+            if (isLoggedIn) {
+                // Logged in user
+                const requestParams = config.hasVariants
+                    ? { ...params, cartResourceType }
+                    : { ...params, ...cleanObject(checkoutData), cartResourceType };
+                // Include itemId if provided for update operations
+                if (params.itemId) {
+                    requestParams.itemId = params.itemId;
+                }
+                const { data } = await api.post('toggle-cart-item', requestParams, selectedLang);
+                set({
+                    ...data,
+                    itemsCount: data.itemsCount ?? data.items_qty ?? 0,
+                    items: data.items ?? [],
+                    useBalance: data.useBalance || null,
+                    promotion_code: data.promotion_code || null,
+                    promotion_error: data.promotion_error || null,
+                }, false, 'cart/addItem/success');
+                // Auto-sync checkout data
+                get().updateCheckoutData({
+                    useBalance: data.useBalance || null,
+                    promotion_code: data.promotion_code || null,
+                    promotion_error: data.promotion_error || null,
+                });
+            }
+            else {
+                // Guest user - update cookie
+                const cookieItems = parseCookieCart(getCookie('cart'));
+                const newItem = {
+                    productId: params.productId,
+                    qty: params.qty,
+                    ...(config.hasVariants && params.variantId && params.optionId
+                        ? { variantId: params.variantId, optionId: params.optionId }
+                        : {}),
+                };
+                const updatedItems = addOrUpdateItem(cookieItems, newItem, config.hasVariants);
+                setCookie('cart', serializeCartToCookie(updatedItems));
+                // Refresh cart from server
+                await get().getCart();
+            }
+        }
+        catch (error) {
+            console.error('Error adding item to cart:', error);
+        }
+    },
+    /**
+     * Remove item from cart
+     */
+    removeItem: async (params) => {
+        const { config, isLoggedIn, selectedLang, checkoutData } = get();
+        const cartResourceType = getCartResourceType();
+        try {
+            if (isLoggedIn) {
+                // Logged in user
+                const requestParams = config.hasVariants
+                    ? { ...params, cartResourceType }
+                    : { ...params, ...cleanObject(checkoutData), cartResourceType };
+                const { data } = await api.post('delete-cart-item', requestParams, selectedLang);
+                set({
+                    ...data,
+                    itemsCount: data.itemsCount ?? data.items_qty ?? 0,
+                    items: data.items ?? [],
+                    useBalance: data.useBalance || null,
+                    promotion_code: data.promotion_code || null,
+                    promotion_error: data.promotion_error || null,
+                }, false, 'cart/removeItem/success');
+                // Auto-sync checkout data
+                get().updateCheckoutData({
+                    useBalance: data.useBalance || null,
+                    promotion_code: data.promotion_code || null,
+                    promotion_error: data.promotion_error || null,
+                });
+            }
+            else {
+                // Guest user - update cookie
+                const cookieItems = parseCookieCart(getCookie('cart'));
+                const targetItem = {
+                    productId: params.productId,
+                    qty: 0,
+                    ...(config.hasVariants && params.variantId && params.optionId
+                        ? { variantId: params.variantId, optionId: params.optionId }
+                        : {}),
+                };
+                const updatedItems = removeItem(cookieItems, targetItem, config.hasVariants);
+                setCookie('cart', serializeCartToCookie(updatedItems));
+                // Refresh cart from server
+                await get().getCart();
+            }
+        }
+        catch (error) {
+            console.error('Error removing item from cart:', error);
+        }
+    },
+    /**
+     * Update item quantity
+     */
+    updateItem: async (params) => {
+        const { config } = get();
+        // If quantity is 0, remove the item
+        if (params.qty === 0) {
+            return get().removeItem(params);
+        }
+        // Otherwise, add/update the item
+        return get().addItem(params);
+    },
+    /**
+     * Clear entire cart
+     */
+    clearCart: async () => {
+        const { isLoggedIn, selectedLang } = get();
+        try {
+            get().resetCart();
+            if (isLoggedIn) {
+                const { data } = await api.post('clear-cart', {}, selectedLang);
+                set({
+                    ...data,
+                    itemsCount: data.itemsCount ?? data.items_qty ?? 0,
+                    items: data.items ?? [],
+                }, false, 'cart/clearCart/success');
+            }
+            else {
+                await get().getCart();
+            }
+        }
+        catch (error) {
+            console.error('Error clearing cart:', error);
+        }
+    },
+    /**
+     * Sync cart (for logged in users with cookie cart)
+     */
+    syncCart: async () => {
+        const { selectedLang } = get();
+        const cookieItems = parseCookieCart(getCookie('cart'));
+        if (cookieItems.length > 0) {
+            try {
+                const { data } = await api.post('sync-cart', { items: cookieItems }, selectedLang);
+                set({
+                    ...data,
+                    itemsCount: data.itemsCount ?? data.items_qty ?? 0,
+                    items: data.items ?? [],
+                }, false, 'cart/syncCart/success');
+            }
+            catch (error) {
+                console.error('Error syncing cart:', error);
+            }
+        }
+    },
+    /**
+     * Merge cart (when logging in)
+     */
+    mergeCart: async () => {
+        const { selectedLang } = get();
+        const cookieItems = parseCookieCart(getCookie('cart'));
+        if (cookieItems.length > 0) {
+            try {
+                removeCookie('cart');
+                const { data } = await api.post('merge-cart', { items: cookieItems }, selectedLang);
+                set({
+                    ...data,
+                    itemsCount: data.itemsCount ?? data.items_qty ?? 0,
+                    items: data.items ?? [],
+                }, false, 'cart/mergeCart/success');
+            }
+            catch (error) {
+                console.error('Error merging cart:', error);
+            }
+        }
+    },
+    /**
+     * Update checkout data (with session storage persistence)
+     */
+    updateCheckoutData: (data) => {
+        set((state) => {
+            const updatedCheckoutData = { ...state.checkoutData, ...data };
+            saveCheckoutDataToSession(updatedCheckoutData);
+            return { checkoutData: updatedCheckoutData };
+        }, false, 'cart/updateCheckoutData');
+    },
+    /**
+     * Fill checkout data (legacy method with flexible arguments)
+     */
+    fillCheckoutData: (keyOrObject, value) => {
+        const { checkoutData } = get();
+        let updatedData;
+        if (typeof keyOrObject === 'string') {
+            updatedData = { [keyOrObject]: value };
+        }
+        else {
+            updatedData = keyOrObject;
+        }
+        const newCheckoutData = { ...checkoutData, ...updatedData };
+        saveCheckoutDataToSession(newCheckoutData);
+        set({ checkoutData: newCheckoutData }, false, 'cart/fillCheckoutData');
+    },
+    /**
+     * Fill cart (updates checkout data and refreshes cart)
+     */
+    fillCart: (key, value) => {
+        const updatedData = { [key]: value };
+        get().updateCheckoutData(updatedData);
+        get().getCart(updatedData);
+    },
+    /**
+     * Set gifts selection
+     */
+    setGifts: ({ promotionId, qty, productId }) => {
+        const { checkoutData } = get();
+        const updatedGifts = checkoutData.gifts.map((item) => {
+            if (item.promotionId === promotionId && item.productId === productId) {
+                return { ...item, qty };
+            }
+            return item;
+        });
+        get().updateCheckoutData({ gifts: updatedGifts });
+    },
+    /**
+     * Toggle promotion (exclude/include)
+     */
+    togglePromotion: ({ promotionId }) => {
+        const { checkoutData } = get();
+        const excludedPromotions = [...checkoutData.excludedPromotions];
+        const index = excludedPromotions.indexOf(promotionId);
+        if (index > -1) {
+            excludedPromotions.splice(index, 1);
+        }
+        else {
+            excludedPromotions.push(promotionId);
+        }
+        const updatedData = { excludedPromotions };
+        get().updateCheckoutData(updatedData);
+        get().getCart(updatedData);
+    },
+    /**
+     * Reorder from previous order
+     */
+    reorder: async (orderId) => {
+        const { selectedLang } = get();
+        await api.post('reorder', { orderId }, selectedLang);
+        // Redirect to cart page
+        if (typeof window !== 'undefined') {
+            window.location.href = `/${selectedLang}/cart`;
+        }
+    },
+    /**
+     * Set Idram payment form
+     */
+    setIdramForm: (form) => {
+        set({ idramFormData: form }, false, 'cart/setIdramForm');
+    },
+    /**
+     * Submit Idram payment form
+     */
+    submitIdramPayment: () => {
+        const { idramFormData } = get();
+        if (idramFormData && typeof document !== 'undefined') {
+            const form = document.createElement('form');
+            form.action = idramFormData.url;
+            form.method = 'POST';
+            // Add language field
+            const langInput = document.createElement('input');
+            langInput.type = 'hidden';
+            langInput.name = 'EDP_LANGUAGE';
+            langInput.value = idramFormData.language;
+            form.appendChild(langInput);
+            // Add form fields
+            Object.keys(idramFormData.form).forEach((key) => {
+                const input = document.createElement('input');
+                input.type = 'hidden';
+                input.name = key;
+                input.value = idramFormData.form[key];
+                form.appendChild(input);
+            });
+            document.body.appendChild(form);
+            form.submit();
+            get().resetCart();
+        }
+    },
+    /**
+     * Checkout (with advanced payment handling)
+     */
+    checkout: async () => {
+        const { checkoutData, itemsCount, selectedLang, user } = get();
+        if (itemsCount === 0) {
+            throw new Error('Cart is empty');
+        }
+        // Card validation
+        if (isNumeric(checkoutData.paymentType)) {
+            const selectedCard = user?.cards?.find((card) => card.id === checkoutData.paymentType);
+            if (!selectedCard || selectedCard.is_expired) {
+                alert('The selected card is expired. Please choose another payment method.');
+                throw new Error('Card is expired');
+            }
+        }
+        try {
+            set({ loading: true }, false, 'cart/checkout/start');
+            const payload = {
+                ...cleanObject(checkoutData),
+            };
+            // Remove empty gifts array
+            if (!payload.gifts?.length) {
+                delete payload.gifts;
+            }
+            // Handle credit card payment
+            if (isNumeric(checkoutData.paymentType)) {
+                payload.paymentType = 'credit_card';
+                payload.card_id = Number(checkoutData.paymentType);
+            }
+            // Handle new credit card
+            if (checkoutData.paymentType === 'credit_card') {
+                payload.card_id = 0;
+            }
+            const response = await api.post('checkout', payload, selectedLang);
+            set({ loading: false }, false, 'cart/checkout/success');
+            // Handle response
+            if (response.redirect_url) {
+                // Redirect to success page
+                if (typeof window !== 'undefined') {
+                    window.location.href = response.redirect_url;
+                }
+            }
+            else if (response.url) {
+                // Idram payment
+                const lang = selectedLang === 'en' ? 'EN' : selectedLang === 'ru' ? 'RU' : 'AM';
+                get().setIdramForm({
+                    url: response.url,
+                    form: response.form,
+                    language: lang,
+                });
+                // Submit form after a short delay
+                setTimeout(() => {
+                    get().submitIdramPayment();
+                }, 100);
+            }
+            else {
+                // Success without redirect
+                get().resetCart();
+            }
+            return response;
+        }
+        catch (error) {
+            set({ loading: false }, false, 'cart/checkout/error');
+            throw error;
+        }
+    },
+    /**
+     * Reset cart to initial state
+     */
+    resetCart: () => {
+        const { user } = get();
+        removeCookie('cart');
+        if (typeof sessionStorage !== 'undefined') {
+            sessionStorage.clear();
+        }
+        const resetCheckoutData = {
+            addressId: null,
+            billingAddressId: null,
+            shippingAddressId: null,
+            useBalance: null,
+            note: '',
+            paymentType: user?.payment_method || 'cash_on_delivery',
+            gifts: [],
+            card_id: user?.payment_method === 'credit_card' ? user.card_id : null,
+            excludedPromotions: [],
+            promotion_code: null,
+            promotion_error: null,
+            utensils: [],
+        };
+        set({
+            ...initialCartState,
+            checkoutData: resetCheckoutData,
+            loading: false,
+        }, false, 'cart/reset');
+    },
+}), { name: 'CartStore' }));
+// Subscribe to cart changes for auto-sync of gifts and utensils
+useCartStore.subscribe((state, prevState) => {
+    if (state.items !== prevState.items) {
+        const currentGiftMap = new Map(state.checkoutData.gifts?.map((g) => [`${g.promotionId}-${g.productId}`, g]) || []);
+        // Build gifts array based on current cart items (source of truth)
+        const updatedGifts = state.items
+            .filter((item) => item.is_gift && item.appliedPromotion)
+            .map((item) => {
+            const key = `${item.appliedPromotion.id}-${item.product.id}`;
+            if (currentGiftMap.has(key)) {
+                const existingGift = currentGiftMap.get(key);
+                if (existingGift.qty === 0) {
+                    return existingGift;
+                }
+                return {
+                    ...existingGift,
+                    qty: item.qty,
+                };
+            }
+            return {
+                productId: item.product.id,
+                promotionId: item.appliedPromotion.id,
+                qty: item.qty,
+            };
+        });
+        const hasChanged = updatedGifts.length !== (state.checkoutData.gifts?.length || 0) ||
+            updatedGifts.some((gift, i) => {
+                const oldGift = state.checkoutData.gifts?.[i];
+                return (!oldGift ||
+                    gift.productId !== oldGift.productId ||
+                    gift.promotionId !== oldGift.promotionId ||
+                    gift.qty !== oldGift.qty);
+            });
+        if (hasChanged) {
+            useCartStore.getState().updateCheckoutData({ gifts: updatedGifts });
+        }
+    }
+    // Auto-sync utensils when cart utensils change
+    if (state.utensils !== prevState.utensils) {
+        const currentUtensils = new Map(state.checkoutData.utensils?.map((g) => [g.utensilId, g]) || []);
+        // Build utensils array based on current cart utensils (source of truth)
+        const updatedUtensils = state.utensils.map((item) => {
+            // If utensil exists in old checkout data, keep it (preserves user selections)
+            if (currentUtensils.has(item.id)) {
+                return currentUtensils.get(item.id);
+            }
+            // Otherwise, create new utensil entry
+            return {
+                utensilId: item.id,
+                isChecked: true,
+            };
+        });
+        // Update if utensils changed (added, removed, or modified)
+        const hasChanged = updatedUtensils.length !== (state.checkoutData.utensils?.length || 0) ||
+            updatedUtensils.some((utensil, i) => {
+                const oldUtensil = state.checkoutData.utensils?.[i];
+                return !oldUtensil || utensil.utensilId !== oldUtensil.utensilId;
+            });
+        if (hasChanged) {
+            useCartStore.getState().updateCheckoutData({ utensils: updatedUtensils });
+        }
+    }
+});
+/**
+ * Initialize cart store
+ * Call this once when your app starts
+ */
+export function initCartStore(config, isLoggedIn, selectedLang = 'en', user = null) {
+    // Check if on cart/checkout page
+    const isCheckoutPage = typeof window !== 'undefined' && window.location.href.includes('checkout');
+    const isCartPage = typeof window !== 'undefined' && window.location.href.includes('cart');
+    // Handle URL parameters for saved card
+    if (typeof window !== 'undefined') {
+        const params = new URLSearchParams(window.location.search);
+        if (params.get('cardSaved') === '1' && params.get('cardId')) {
+            const checkoutData = useCartStore.getState().checkoutData;
+            useCartStore.getState().updateCheckoutData({
+                paymentType: params.get('cardId'),
+                card_id: Number(params.get('cardId')),
+            });
+            // Clean URL
+            params.delete('cardSaved');
+            params.delete('cardId');
+            const newUrl = `${window.location.pathname}${params.toString() ? '?' + params.toString() : ''}`;
+            window.history.replaceState({}, '', newUrl);
+        }
+    }
+    // Initialize checkout data with user info
+    const initialCheckoutWithUser = user
+        ? {
+            ...loadCheckoutDataFromSession(),
+            paymentType: user.payment_method || 'cash_on_delivery',
+            card_id: user.payment_method === 'credit_card' ? user.card_id : null,
+        }
+        : loadCheckoutDataFromSession();
+    useCartStore.setState({
+        config,
+        isLoggedIn,
+        selectedLang,
+        user,
+        isCheckoutPage,
+        isCartPage,
+        checkoutData: initialCheckoutWithUser,
+    });
+}
+//# sourceMappingURL=cartStore.js.map