@q2devel/q2-core 1.0.0

package/dist/context/cart/BasketContext.js

@@ -0,0 +1,408 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAddToCart } from '../../hooks/cart/api/useAddToCart';
+import { useClearCart } from '../../hooks/cart/api/useClearCart';
+import { useDeleteCartItem } from '../../hooks/cart/api/useDeleteCartItem';
+import { useGetCartToken } from '../../hooks/cart/api/useGetCartToken';
+import { useGetCurrentCart } from '../../hooks/cart/api/useGetCurrentCart';
+import { useGetUserCart } from '../../hooks/cart/api/useGetUserCart';
+import { useUpdateCartItem } from '../../hooks/cart/api/useUpdateCart';
+import { useUpdateCheckout } from '../../hooks/checkout/useUpdateCheckout';
+import { formatPrice } from '../../utils/generalHelper';
+import { createContext, useContext, useEffect, useRef, useState } from 'react';
+const BasketContext = createContext(undefined);
+export const BasketProvider = ({ children, ctx }) => {
+    const [basketProducts, setBasketProducts] = useState([]);
+    const [isBasketOpen, setIsBasketOpen] = useState(false);
+    const [orderId, setOrderId] = useState(null);
+    const [drupalOrderId, setDrupalOrderId] = useState(null);
+    const { getExistingCartToken, createCartToken, cartToken } = useGetCartToken(ctx);
+    const activeToken = cartToken;
+    console.log('Aktivní token:', activeToken);
+    const { data: userCartData, isLoading: isUserCartLoading, refetch: refetchUserCart, isFetching: isUserCartFetching, } = useGetUserCart(ctx);
+    const { data: guestCartData, isLoading: isGuestCartLoading, refetch: refetchGuestCart, isFetching: isGuestCartFetching, } = useGetCurrentCart({ activeToken: activeToken ?? undefined, ctx });
+    const cartData = ctx.userId ? userCartData : guestCartData;
+    const isLoading = ctx.userId ? isUserCartLoading : isGuestCartLoading;
+    const isFetching = ctx.userId ? isUserCartFetching : isGuestCartFetching;
+    const refetchCart = ctx.userId ? refetchUserCart : refetchGuestCart;
+    const { mutateAsync: addToCartMutation, isPending: isAddingToCart } = useAddToCart(ctx, activeToken ?? undefined);
+    const { mutateAsync: updateCartItemMutation } = useUpdateCartItem(ctx);
+    const { mutateAsync: deleteCartItemMutation } = useDeleteCartItem(ctx);
+    const { mutateAsync: clearCartMutation } = useClearCart(ctx);
+    const { mutateAsync: updateCheckoutMutation } = useUpdateCheckout(ctx);
+    const debounceTimersRef = useRef({});
+    const [pendingUpdates, setPendingUpdates] = useState({});
+    const DEBOUNCE_DELAY = 600;
+    const [processingItems, setProcessingItems] = useState({});
+    useEffect(() => {
+        return () => {
+            const timers = debounceTimersRef.current;
+            Object.values(timers).forEach(clearTimeout);
+        };
+    }, []);
+    useEffect(() => {
+        if (ctx.accessToken) {
+            // Přihlášený uživatel, token je v userToken
+        }
+        else {
+            const existingToken = localStorage.getItem('cartToken');
+            if (existingToken) {
+                getExistingCartToken();
+            }
+            else {
+                createCartToken();
+            }
+        }
+    }, [ctx.accessToken]);
+    // Synchronizace data z API
+    useEffect(() => {
+        if (cartData?.data?.cartItems) {
+            const transformedProducts = cartData.data.cartItems.map((item) => {
+                const priceNumber = parseFloat(item.price.toString());
+                return {
+                    variation_id: item.variation_id,
+                    variation_uuid: item.variation_uuid,
+                    type: 'product',
+                    variation_name: item.variation_name,
+                    description: '',
+                    price: priceNumber,
+                    formattedPrice: formatPrice(priceNumber, ctx.locale),
+                    quantity: item.quantity,
+                    images: item.images || [],
+                    category: '',
+                    field_news: item.field_news || false,
+                    field_aftersale: item.field_aftersale || false,
+                    field_care: [],
+                    field_features: [],
+                    field_returns: [],
+                    field_shipping: [],
+                    href: '/',
+                    drupalOrderItemId: item.drupalOrderItemId?.toString(),
+                    order_item_id: item.order_item_id,
+                };
+            });
+            setBasketProducts(transformedProducts);
+            if (cartData.data.drupalOrderId) {
+                setDrupalOrderId(cartData.data.drupalOrderId);
+            }
+        }
+        else if (cartData &&
+            (!cartData.data?.cartItems || cartData.data.cartItems.length === 0)) {
+            setBasketProducts([]);
+            if (drupalOrderId === null) {
+                setDrupalOrderId(null);
+            }
+        }
+    }, [cartData, ctx.locale]);
+    const calculateSubtotal = () => {
+        const total = basketProducts.reduce((sum, product) => {
+            const priceValue = typeof product.price === 'string'
+                ? parseFloat(product.price.replace(/[^\d,.-]/g, '').replace(',', '.'))
+                : Number(product.price);
+            return sum + priceValue * product.quantity;
+        }, 0);
+        return total;
+    };
+    const calculateTotalItems = () => {
+        return basketProducts.reduce((sum, product) => {
+            return sum + product.quantity;
+        }, 0);
+    };
+    const getProductQuantityInBasket = (productId) => {
+        const productInBasket = basketProducts.find((p) => p.variation_uuid === productId);
+        return productInBasket ? productInBasket.quantity : 0;
+    };
+    // Merged addToBasket function - directly calls API
+    const addToBasket = async (product, quantity = 1) => {
+        const productKey = product.variation_uuid;
+        setProcessingItems((prev) => ({
+            ...prev,
+            [productKey]: true,
+        }));
+        const safetyTimeout = setTimeout(() => {
+            setProcessingItems((prev) => {
+                const newState = { ...prev };
+                delete newState[productKey];
+                return newState;
+            });
+        }, 4000);
+        try {
+            let token = ctx.accessToken || cartToken;
+            if (!token && !ctx.accessToken) {
+                const existingToken = localStorage.getItem('cartToken');
+                if (existingToken) {
+                    token = existingToken;
+                    getExistingCartToken();
+                }
+                else {
+                    token = createCartToken();
+                }
+            }
+            const request = {
+                data: [
+                    {
+                        type: 'commerce_product_variation--default',
+                        id: product.variation_uuid,
+                        meta: {
+                            quantity,
+                            combine: true,
+                        },
+                    },
+                ],
+            };
+            const response = await addToCartMutation(request);
+            if (response?.[0]?.order_id) {
+                setOrderId(Number(response[0].order_id));
+            }
+            // Remove refetchCart() - hook should handle cache update
+        }
+        catch (error) {
+            // Only refetch on error as fallback
+            await refetchCart();
+            throw error;
+        }
+        finally {
+            clearTimeout(safetyTimeout);
+            setProcessingItems((prev) => {
+                const newState = { ...prev };
+                delete newState[productKey];
+                return newState;
+            });
+        }
+    };
+    const addMultipleToBasket = async (products, quantity = 1) => {
+        if (!products.length || isAddingToCart)
+            return;
+        try {
+            const request = {
+                data: products.map((product) => ({
+                    type: 'commerce_product_variation--default',
+                    id: product.variation_uuid,
+                    meta: {
+                        quantity,
+                        combine: true,
+                    },
+                })),
+            };
+            const response = await addToCartMutation(request);
+            if (response?.[0]?.order_id) {
+                setOrderId(Number(response[0].order_id));
+            }
+        }
+        catch (error) {
+            console.error('Chyba pri hromadnom pridávaní produktov:', error);
+            await refetchCart(); // fallback
+        }
+    };
+    const removeFromBasket = async (productId) => {
+        const productToRemove = basketProducts.find((p) => p.variation_uuid === productId);
+        if (!productToRemove)
+            return;
+        const productKey = productToRemove.variation_uuid;
+        setProcessingItems((prev) => ({
+            ...prev,
+            [productKey]: true,
+        }));
+        // Cancel any pending debounce for this product
+        if (debounceTimersRef.current[productKey]) {
+            clearTimeout(debounceTimersRef.current[productKey]);
+            delete debounceTimersRef.current[productKey];
+        }
+        // Clear pending updates
+        setPendingUpdates((prev) => {
+            const newState = { ...prev };
+            delete newState[productKey];
+            return newState;
+        });
+        try {
+            if (!activeToken || !drupalOrderId)
+                return;
+            const deleteId = productToRemove.order_item_id;
+            await deleteCartItemMutation({
+                orderId: drupalOrderId.toString(),
+                request: {
+                    data: [
+                        {
+                            type: 'commerce_order_item--default',
+                            id: deleteId,
+                        },
+                    ],
+                },
+            });
+            await refetchCart();
+        }
+        catch (error) {
+            await refetchCart();
+        }
+        finally {
+            setProcessingItems((prev) => {
+                const newState = { ...prev };
+                delete newState[productKey];
+                return newState;
+            });
+        }
+    };
+    // Clear pending updates when cart stops fetching and data matches
+    useEffect(() => {
+        // Only clear when not fetching anymore
+        if (!isFetching) {
+            Object.keys(pendingUpdates).forEach((productKey) => {
+                const product = basketProducts.find((p) => p.variation_uuid === productKey);
+                const pendingQuantity = pendingUpdates[productKey];
+                if (product && product.quantity === pendingQuantity) {
+                    setPendingUpdates((prev) => {
+                        const newState = { ...prev };
+                        delete newState[productKey];
+                        return newState;
+                    });
+                }
+            });
+        }
+    }, [basketProducts, pendingUpdates, isFetching]);
+    // Simplified updateQuantity function
+    const updateQuantity = async (productId, quantity) => {
+        const productInBasket = basketProducts.find((p) => p.variation_uuid === productId);
+        if (!productInBasket)
+            return;
+        // Handle removal
+        if (quantity <= 0) {
+            await removeFromBasket(productId);
+            return;
+        }
+        const productKey = productId;
+        // Show pending quantity immediately in UI
+        setPendingUpdates((prev) => ({
+            ...prev,
+            [productKey]: quantity,
+        }));
+        // Clear existing timer
+        if (debounceTimersRef.current[productKey]) {
+            clearTimeout(debounceTimersRef.current[productKey]);
+        }
+        // Set new debounced timer
+        debounceTimersRef.current[productKey] = setTimeout(async () => {
+            setProcessingItems((prev) => ({
+                ...prev,
+                [productKey]: true,
+            }));
+            try {
+                if (!activeToken || !drupalOrderId)
+                    return;
+                const itemId = getDrupalOrderItemId(productInBasket);
+                const request = {
+                    data: {
+                        type: 'order-items--default',
+                        id: productInBasket.order_item_id,
+                        attributes: { quantity },
+                    },
+                };
+                await updateCartItemMutation({
+                    orderId: drupalOrderId.toString(),
+                    itemId: itemId,
+                    request,
+                });
+                await refetchCart();
+                // Don't clear pending updates here - let the useEffect handle it
+            }
+            catch (error) {
+                await refetchCart();
+                // Clear pending updates on error
+                setPendingUpdates((prev) => {
+                    const newState = { ...prev };
+                    delete newState[productKey];
+                    return newState;
+                });
+            }
+            finally {
+                setProcessingItems((prev) => {
+                    const newState = { ...prev };
+                    delete newState[productKey];
+                    return newState;
+                });
+                delete debounceTimersRef.current[productKey];
+            }
+        }, DEBOUNCE_DELAY);
+    };
+    const getDrupalOrderItemId = (product) => {
+        return (product.drupalOrderItemId?.toString() ||
+            product.variation_uuid);
+    };
+    // Updated clearBasket without queue operations
+    const clearBasket = async () => {
+        try {
+            if (drupalOrderId) {
+                await clearCartMutation({
+                    orderId: drupalOrderId.toString(),
+                });
+                await refetchCart();
+            }
+            // Clear all pending updates
+            setPendingUpdates({});
+            // Clear all debounce timers
+            const timers = debounceTimersRef.current;
+            Object.values(timers).forEach(clearTimeout);
+            debounceTimersRef.current = {};
+        }
+        catch (error) {
+            await refetchCart();
+        }
+    };
+    const openBasket = () => {
+        setIsBasketOpen(true);
+    };
+    const closeBasket = () => {
+        setIsBasketOpen(false);
+    };
+    const updateOrderForCheckout = async (request, callbacks) => {
+        if (!drupalOrderId) {
+            return;
+        }
+        try {
+            await updateCheckoutMutation({
+                orderId: drupalOrderId.toString(),
+                request,
+            });
+            await refetchCart();
+            if (callbacks?.onSuccess) {
+                callbacks.onSuccess();
+            }
+        }
+        catch (error) {
+            if (callbacks?.onError) {
+                callbacks.onError(error);
+            }
+            throw error;
+        }
+    };
+    const getDrupalOrderId = () => {
+        return drupalOrderId;
+    };
+    const value = {
+        basketProducts,
+        subtotal: calculateSubtotal(),
+        totalItems: calculateTotalItems(),
+        addToBasket,
+        addMultipleToBasket,
+        removeFromBasket,
+        updateQuantity,
+        clearBasket,
+        isBasketOpen,
+        openBasket,
+        closeBasket,
+        isLoading,
+        getProductQuantityInBasket,
+        updateOrderForCheckout,
+        getDrupalOrderId,
+        pendingUpdates,
+        processingItems,
+        isAddingToCart,
+    };
+    return _jsx(BasketContext.Provider, { value: value, children: children });
+};
+export const useBasket = () => {
+    const context = useContext(BasketContext);
+    if (context === undefined) {
+        throw new Error('useBasket musí být použit uvnitř BasketProvider');
+    }
+    return context;
+};

package/dist/context.d.ts

@@ -0,0 +1,14 @@
+import { AxiosInstance } from 'axios';
+export type CoreContext = {
+    axios: AxiosInstance;
+    defaultLocale: string;
+    locale: string;
+    accessToken?: string;
+    baseUrl?: string;
+    userId?: string;
+    cartToken?: string;
+    makeAbsoluteUrl: (path: string) => string;
+    getCache?: <T = any>(key: string) => Promise<T | null>;
+    setCache?: <T = any>(key: string, value: T) => Promise<void>;
+};
+//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAEtC,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,aAAa,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC1C,QAAQ,CAAC,EAAE,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACvD,QAAQ,CAAC,EAAE,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9D,CAAC"}

package/dist/context.js

@@ -0,0 +1 @@
+export {};

package/dist/hooks/cart/api/useAddToCart.d.ts

@@ -0,0 +1,4 @@
+import { AddToCartRequest, AddToCartResponse } from '../../../api/cart/CartService.types';
+import { CoreContext } from '../../../context';
+export declare const useAddToCart: (ctx: CoreContext, activeToken?: string) => import("@tanstack/react-query").UseMutationResult<AddToCartResponse, Error, AddToCartRequest, unknown>;
+//# sourceMappingURL=useAddToCart.d.ts.map

package/dist/hooks/cart/api/useAddToCart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAddToCart.d.ts","sourceRoot":"","sources":["../../../../hooks/cart/api/useAddToCart.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAC1F,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,eAAO,MAAM,YAAY,GAAI,KAAK,WAAW,EAAE,cAAa,MAAM,2GAcjE,CAAC"}

package/dist/hooks/cart/api/useAddToCart.js

@@ -0,0 +1,17 @@
+// src/hooks/api/cart/useAddToCart.ts
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { addToCart } from '../../../api/cart/Cart.service';
+export const useAddToCart = (ctx, activeToken) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (request) => addToCart(ctx, activeToken, request),
+        onSuccess: () => {
+            if (ctx.userId) {
+                queryClient.invalidateQueries({ queryKey: ['userCart'] });
+            }
+            else {
+                queryClient.invalidateQueries({ queryKey: ['cart'] });
+            }
+        },
+    });
+};

package/dist/hooks/cart/api/useClearCart.d.ts

@@ -0,0 +1,5 @@
+import { CoreContext } from '../../../context';
+export declare const useClearCart: (ctx: CoreContext) => import("@tanstack/react-query").UseMutationResult<void, Error, {
+    orderId: string;
+}, unknown>;
+//# sourceMappingURL=useClearCart.d.ts.map

package/dist/hooks/cart/api/useClearCart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useClearCart.d.ts","sourceRoot":"","sources":["../../../../hooks/cart/api/useClearCart.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,eAAO,MAAM,YAAY,GAAI,KAAK,WAAW;aAGA,MAAM;WAWlD,CAAC"}

package/dist/hooks/cart/api/useClearCart.js

@@ -0,0 +1,17 @@
+// src/hooks/api/cart/useClearCart.ts
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { clearCart } from '../../../api/cart/Cart.service';
+export const useClearCart = (ctx) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ orderId }) => clearCart(ctx, orderId),
+        onSuccess: () => {
+            if (ctx.userId) {
+                queryClient.invalidateQueries({ queryKey: ['userCart'] });
+            }
+            else {
+                queryClient.invalidateQueries({ queryKey: ['cart'] });
+            }
+        },
+    });
+};

package/dist/hooks/cart/api/useDeleteCartItem.d.ts

@@ -0,0 +1,7 @@
+import { DeleteCartItemRequest } from '../../../api/cart/CartService.types';
+import { CoreContext } from '../../../context';
+export declare const useDeleteCartItem: (ctx: CoreContext) => import("@tanstack/react-query").UseMutationResult<void, Error, {
+    request: DeleteCartItemRequest;
+    orderId: string;
+}, unknown>;
+//# sourceMappingURL=useDeleteCartItem.d.ts.map

package/dist/hooks/cart/api/useDeleteCartItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDeleteCartItem.d.ts","sourceRoot":"","sources":["../../../../hooks/cart/api/useDeleteCartItem.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,eAAO,MAAM,iBAAiB,GAAI,KAAK,WAAW;aAGL,qBAAqB;aAAW,MAAM;WAuBlF,CAAC"}

package/dist/hooks/cart/api/useDeleteCartItem.js

@@ -0,0 +1,24 @@
+// src/hooks/api/cart/useDeleteCartItem.ts
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { deleteCartItem } from '../../../api/cart/Cart.service';
+export const useDeleteCartItem = (ctx) => {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ request, orderId }) => deleteCartItem(ctx, orderId, request),
+        onSuccess: (_, variables) => {
+            const queryKey = ctx.userId ? ['userCart', ctx.userId] : ['cart'];
+            queryClient.setQueryData(queryKey, (oldData) => {
+                if (!oldData?.data?.cartItems)
+                    return oldData;
+                const itemIdToRemove = variables.request.data[0].id;
+                return {
+                    ...oldData,
+                    data: {
+                        ...oldData.data,
+                        cartItems: oldData.data.cartItems.filter((item) => item.id !== itemIdToRemove),
+                    },
+                };
+            });
+        },
+    });
+};