@meeovi/layer-commerce 1.0.5 → 1.0.7

package/dist/composables/stores/cartStore.js

@@ -1,246 +0,0 @@
-// stores/cartStore.ts
-import { defineStore } from 'pinia';
-import { MagentoService } from '~/services/magento';
-export const useCartStore = defineStore('cart', {
-    state: () => ({
-        isGuest: true,
-        items: [],
-        total: 0,
-        quoteId: null,
-        magentoService: new MagentoService()
-    }),
-    actions: {
-        async initializeCart() {
-            const auth = useAuth();
-            this.isGuest = !auth.token.value;
-            try {
-                if (this.isGuest) {
-                    await this.createGuestCart();
-                }
-                else {
-                    await this.createCustomerCart();
-                }
-            }
-            catch (error) {
-                errorHandler.handle(error);
-            }
-        },
-        async createGuestCart() {
-            const response = await fetch(`${process.env.MAGENTO_API_URL}/guest-carts`, {
-                method: 'POST'
-            });
-            const quoteId = await response.json();
-            this.quoteId = quoteId;
-        },
-        async createCustomerCart() {
-            const auth = useAuth();
-            const response = await fetch(`${process.env.MAGENTO_API_URL}/carts/mine`, {
-                method: 'POST',
-                headers: {
-                    'Authorization': `Bearer ${auth.token.value}`
-                }
-            });
-            this.quoteId = await response.json();
-        },
-        async addItem(product) {
-            const loading = useLoading();
-            loading.startLoading('Adding to cart...');
-            try {
-                // Check authentication
-                const auth = useAuth();
-                if (auth.isTokenExpired()) {
-                    await auth.refreshAccessToken();
-                }
-                // Check inventory
-                const inventory = useInventory();
-                await inventory.checkInventory(product.sku, product.qty);
-                // If no quote ID, create cart
-                if (!this.quoteId) {
-                    await this.initializeCart();
-                }
-                // Ensure quoteId exists before proceeding
-                if (!this.quoteId) {
-                    throw new CartError('Failed to create cart', 'CART_ERROR');
-                }
-                // Add to Magento cart
-                const response = await fetch(`${process.env.MAGENTO_API_URL}/carts/mine/items`, {
-                    method: 'POST',
-                    headers: {
-                        'Authorization': `Bearer ${auth.token.value}`,
-                        'Content-Type': 'application/json'
-                    },
-                    body: JSON.stringify({
-                        cartItem: {
-                            sku: product.sku,
-                            qty: product.qty,
-                            quote_id: this.quoteId
-                        }
-                    })
-                });
-                if (!response.ok) {
-                    throw new CartError('Failed to add item to cart', 'CART_ERROR');
-                }
-                const cartItem = await response.json();
-                // Update local cart state
-                const existingItem = this.items.find(item => item.sku === product.sku);
-                if (existingItem) {
-                    existingItem.qty += product.qty;
-                }
-                else {
-                    this.items.push({
-                        ...product,
-                        item_id: cartItem.item_id
-                    });
-                }
-                // Calculate taxes
-                const tax = useTax();
-                if (this.quoteId) {
-                    await tax.calculateTax(this.quoteId);
-                }
-                // Cache product data
-                const cache = useCache();
-                cache.setCacheItem(`cart_product_${product.sku}`, product);
-                await this.calculateTotal();
-                loading.stopLoading();
-                const { show } = useNotification();
-                show({
-                    type: 'success',
-                    message: 'Product added to cart'
-                });
-            }
-            catch (error) {
-                loading.stopLoading();
-                errorHandler.handle(error);
-            }
-        },
-        async removeItem(itemId) {
-            const loading = useLoading();
-            loading.startLoading('Removing item...');
-            try {
-                const auth = useAuth();
-                if (auth.isTokenExpired()) {
-                    await auth.refreshAccessToken();
-                }
-                // Remove from Magento cart
-                const response = await fetch(`${process.env.MAGENTO_API_URL}/carts/mine/items/${itemId}`, {
-                    method: 'DELETE',
-                    headers: {
-                        'Authorization': `Bearer ${auth.token.value}`
-                    }
-                });
-                if (!response.ok) {
-                    throw new CartError('Failed to remove item from cart', 'CART_ERROR');
-                }
-                // Update local cart state
-                this.items = this.items.filter(item => item.item_id !== itemId);
-                await this.calculateTotal();
-                loading.stopLoading();
-                useNotification().show({
-                    type: 'success',
-                    message: 'Item removed from cart'
-                });
-            }
-            catch (error) {
-                loading.stopLoading();
-                errorHandler.handle(error);
-            }
-        },
-        async calculateTotal() {
-            try {
-                const auth = useAuth();
-                if (!this.quoteId)
-                    return;
-                // Get cart totals from Magento
-                const response = await fetch(`${process.env.MAGENTO_API_URL}/carts/mine/totals`, {
-                    headers: {
-                        'Authorization': `Bearer ${auth.token.value}`
-                    }
-                });
-                if (!response.ok) {
-                    throw new CartError('Failed to get cart totals', 'CART_ERROR');
-                }
-                const totals = await response.json();
-                this.total = totals.grand_total;
-            }
-            catch (error) {
-                console.error('Error calculating totals:', error);
-                errorHandler.handle(error);
-            }
-        },
-        // Update other methods to use the notification composable
-        async clearCart() {
-            const loading = useLoading();
-            loading.startLoading('Clearing cart...');
-            try {
-                const auth = useAuth();
-                if (this.quoteId) {
-                    const response = await fetch(`${process.env.MAGENTO_API_URL}/carts/mine/clear`, {
-                        method: 'POST',
-                        headers: {
-                            'Authorization': `Bearer ${auth.token.value}`
-                        }
-                    });
-                    if (!response.ok) {
-                        throw new CartError('Failed to clear cart', 'CART_ERROR');
-                    }
-                }
-                this.items = [];
-                this.total = 0;
-                this.quoteId = null;
-                // Clear cart-related cache
-                const cache = useCache();
-                this.items.forEach(item => {
-                    cache.setCacheItem(`cart_product_${item.sku}`, null);
-                });
-                loading.stopLoading();
-                const { show } = useNotification();
-                show({
-                    type: 'success',
-                    message: 'Cart cleared successfully'
-                });
-            }
-            catch (error) {
-                loading.stopLoading();
-                errorHandler.handle(error);
-            }
-        },
-        async syncCartWithMagento() {
-            try {
-                const auth = useAuth();
-                const response = await fetch(`${process.env.MAGENTO_API_URL}/carts/mine/items`, {
-                    headers: {
-                        'Authorization': `Bearer ${auth.token.value}`
-                    }
-                });
-                if (!response.ok) {
-                    throw new CartError('Failed to sync cart', 'CART_ERROR');
-                }
-                const magentoItems = await response.json();
-                this.items = magentoItems;
-                await this.calculateTotal();
-            }
-            catch (error) {
-                errorHandler.handle(error);
-            }
-        },
-        async validateCart() {
-            try {
-                // Check all items inventory
-                for (const item of this.items) {
-                    const inventory = useInventory();
-                    const isAvailable = await inventory.checkInventory(item.sku, item.qty);
-                    if (!isAvailable) {
-                        throw new CartError(`${item.name} is out of stock`, 'INVENTORY_ERROR');
-                    }
-                }
-                // Validate prices
-                await this.syncCartWithMagento();
-                return true;
-            }
-            catch (error) {
-                errorHandler.handle(error);
-                return false;
-            }
-        }
-    }
-});

package/dist/composables/stores/checkout.d.ts

@@ -1 +0,0 @@
-export declare const useCheckoutStore: any;

package/dist/composables/stores/checkout.js

@@ -1,17 +0,0 @@
-import { defineStore } from 'pinia';
-export const useCheckoutStore = defineStore('checkout', {
-    state: () => ({
-        shippingAddress: null,
-        paymentMethod: null,
-        orderId: '',
-        isLoading: false
-    }),
-    actions: {
-        setShippingAddress(address) {
-            this.shippingAddress = address;
-        },
-        setPaymentMethod(method) {
-            this.paymentMethod = method;
-        }
-    }
-});

package/dist/composables/stores/compare.d.ts

@@ -1 +0,0 @@
-export declare const useCompareStore: any;

package/dist/composables/stores/compare.js

@@ -1,50 +0,0 @@
-// stores/compare.ts
-import { defineStore } from 'pinia';
-export const useCompareStore = defineStore('compare', {
-    state: () => ({
-        isLoading: false,
-        count: 0,
-        attributes: [],
-        products: [],
-        productSkus: [],
-        items: []
-    }),
-    actions: {
-        toggleLoader(isLoading) {
-            this.isLoading = isLoading;
-        },
-        setCompareList(payload) {
-            this.attributes = payload.attributes || [];
-            this.products = payload.products || [];
-            this.items = payload.items || [];
-        },
-        removeComparedProduct(productSku) {
-            this.products = this.products.filter(product => product.sku !== productSku);
-            this.productSkus = this.productSkus.filter(sku => sku !== productSku);
-            this.items = this.items.filter(item => item.product.sku !== productSku);
-        },
-        clearComparedProducts() {
-            this.products = [];
-            this.productSkus = [];
-            this.items = [];
-            this.count = 0;
-        },
-        setCompareListSkus(productSkus) {
-            this.productSkus = productSkus;
-        },
-        addComparedProductSku(productSku) {
-            if (!this.productSkus.includes(productSku)) {
-                this.productSkus.push(productSku);
-            }
-        },
-        updateCompareTotals(compareTotals) {
-            this.count = parseInt(compareTotals, 10); // Convert string to number
-        }
-    },
-    getters: {
-        getCompareCount: (state) => state.count,
-        getComparedProducts: (state) => state.products,
-        getComparedProductSkus: (state) => state.productSkus,
-        getIsLoading: (state) => state.isLoading
-    }
-});

package/dist/composables/stores/orders.d.ts

@@ -1 +0,0 @@
-export declare const useOrdersStore: any;

package/dist/composables/stores/orders.js

@@ -1,156 +0,0 @@
-export const useOrdersStore = defineStore('orders', () => {
-    const orders = ref([]);
-    const currentOrder = ref(null);
-    const returns = ref([]);
-    const transactions = ref([]);
-    const invoices = ref([]);
-    const creditMemos = ref([]);
-    const loading = ref(false);
-    const error = ref(null);
-    // Import composables
-    const { getOrders, getOrderById } = useOrders();
-    const { getReturns, createReturn } = useReturns();
-    const { getTransactions } = useTransactions();
-    const { getInvoices } = useInvoices();
-    const { getCreditMemos } = useCreditMemos();
-    const fetchOrders = async (filters = {}) => {
-        loading.value = true;
-        error.value = null;
-        try {
-            orders.value = await getOrders(filters);
-        }
-        catch (err) {
-            error.value = err.message;
-            console.error('Error fetching orders:', err);
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    const fetchOrder = async (id) => {
-        loading.value = true;
-        error.value = null;
-        try {
-            currentOrder.value = await getOrderById(id);
-        }
-        catch (err) {
-            error.value = err.message;
-            console.error('Error fetching order:', err);
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    const fetchReturns = async (options = {}) => {
-        loading.value = true;
-        error.value = null;
-        try {
-            returns.value = await getReturns(options);
-        }
-        catch (err) {
-            error.value = err.message;
-            console.error('Error fetching returns:', err);
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    const submitReturn = async (returnData) => {
-        loading.value = true;
-        error.value = null;
-        try {
-            const newReturn = await createReturn(returnData);
-            returns.value.unshift(newReturn);
-            return newReturn;
-        }
-        catch (err) {
-            error.value = err.message;
-            console.error('Error submitting return:', err);
-            throw err;
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    const fetchTransactions = async (options = {}) => {
-        loading.value = true;
-        error.value = null;
-        try {
-            transactions.value = await getTransactions(options);
-        }
-        catch (err) {
-            error.value = err.message;
-            console.error('Error fetching transactions:', err);
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    const fetchInvoices = async (options = {}) => {
-        loading.value = true;
-        error.value = null;
-        try {
-            invoices.value = await getInvoices(options);
-        }
-        catch (err) {
-            error.value = err.message;
-            console.error('Error fetching invoices:', err);
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    const fetchCreditMemos = async (options = {}) => {
-        loading.value = true;
-        error.value = null;
-        try {
-            creditMemos.value = await getCreditMemos(options);
-        }
-        catch (err) {
-            error.value = err.message;
-            console.error('Error fetching credit memos:', err);
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    // Computed properties
-    const ordersByStatus = computed(() => {
-        return orders.value.reduce((acc, order) => {
-            acc[order.status] = (acc[order.status] || 0) + 1;
-            return acc;
-        }, {});
-    });
-    const totalRevenue = computed(() => {
-        return orders.value
-            .filter(order => !['cancelled', 'refunded'].includes(order.status))
-            .reduce((sum, order) => sum + order.total, 0);
-    });
-    const averageOrderValue = computed(() => {
-        const validOrders = orders.value.filter(order => !['cancelled', 'refunded'].includes(order.status));
-        return validOrders.length > 0 ? totalRevenue.value / validOrders.length : 0;
-    });
-    return {
-        // State
-        orders: readonly(orders),
-        currentOrder: readonly(currentOrder),
-        returns: readonly(returns),
-        transactions: readonly(transactions),
-        invoices: readonly(invoices),
-        creditMemos: readonly(creditMemos),
-        loading: readonly(loading),
-        error: readonly(error),
-        // Computed
-        ordersByStatus,
-        totalRevenue,
-        averageOrderValue,
-        // Actions
-        fetchOrders,
-        fetchOrder,
-        fetchReturns,
-        submitReturn,
-        fetchTransactions,
-        fetchInvoices,
-        fetchCreditMemos
-    };
-});

package/dist/composables/stores/product.d.ts

@@ -1 +0,0 @@
-export declare const useProductStore: any;

package/dist/composables/stores/product.js

@@ -1,26 +0,0 @@
-import { defineStore } from 'pinia';
-export const useProductStore = defineStore('product', {
-    state: () => ({
-        products: [],
-        selectedProduct: null,
-        isLoading: false
-    }),
-    actions: {
-        async fetchProducts() {
-            this.isLoading = true;
-            try {
-                const response = await $fetch('/api/products'); // Update API endpoint
-                this.products = response;
-            }
-            catch (error) {
-                console.error('Error fetching products:', error);
-            }
-            finally {
-                this.isLoading = false;
-            }
-        },
-        selectProduct(product) {
-            this.selectedProduct = product;
-        }
-    }
-});

package/dist/composables/stores/products.d.ts

@@ -1 +0,0 @@
-export declare const useProductsStore: any;

package/dist/composables/stores/products.js

@@ -1,106 +0,0 @@
-export const useProductsStore = defineStore('products', () => {
-    const products = ref([]);
-    const featuredProducts = ref([]);
-    const currentProduct = ref(null);
-    const categories = ref([]);
-    const loading = ref(false);
-    const error = ref(null);
-    // Import product composables
-    const { getProducts, getProductById, getProductsByCategory, searchProducts } = useProducts();
-    const { getFeaturedProducts } = useFeaturedProducts();
-    const fetchProducts = async (options = {}) => {
-        loading.value = true;
-        error.value = null;
-        try {
-            products.value = await getProducts(options);
-        }
-        catch (err) {
-            error.value = err.message;
-            console.error('Error fetching products:', err);
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    const fetchProduct = async (id) => {
-        loading.value = true;
-        error.value = null;
-        try {
-            currentProduct.value = await getProductById(id);
-        }
-        catch (err) {
-            error.value = err.message;
-            console.error('Error fetching product:', err);
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    const fetchFeaturedProducts = async (options = {}) => {
-        loading.value = true;
-        error.value = null;
-        try {
-            featuredProducts.value = await getFeaturedProducts(options);
-        }
-        catch (err) {
-            error.value = err.message;
-            console.error('Error fetching featured products:', err);
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    const fetchProductsByCategory = async (categoryId, options = {}) => {
-        loading.value = true;
-        error.value = null;
-        try {
-            products.value = await getProductsByCategory(categoryId, options);
-        }
-        catch (err) {
-            error.value = err.message;
-            console.error('Error fetching products by category:', err);
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    const searchForProducts = async (query, options = {}) => {
-        loading.value = true;
-        error.value = null;
-        try {
-            products.value = await searchProducts(query, options);
-        }
-        catch (err) {
-            error.value = err.message;
-            console.error('Error searching products:', err);
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    // Computed properties
-    const productsOnSale = computed(() => {
-        return products.value.filter(product => product.sale_price && product.sale_price < product.price);
-    });
-    const productCount = computed(() => {
-        return products.value.length;
-    });
-    return {
-        // State
-        products: readonly(products),
-        featuredProducts: readonly(featuredProducts),
-        currentProduct: readonly(currentProduct),
-        categories: readonly(categories),
-        loading: readonly(loading),
-        error: readonly(error),
-        // Computed
-        productsOnSale,
-        productCount,
-        // Actions
-        fetchProducts,
-        fetchProduct,
-        fetchFeaturedProducts,
-        fetchProductsByCategory,
-        searchForProducts
-    };
-});

package/dist/composables/stores/review.d.ts

@@ -1 +0,0 @@
-export declare const useReviewStore: any;

package/dist/composables/stores/review.js

@@ -1,25 +0,0 @@
-import { defineStore } from 'pinia';
-export const useReviewStore = defineStore('review', {
-    state: () => ({
-        reviews: [],
-        isLoading: false
-    }),
-    actions: {
-        async fetchReviews(productId) {
-            this.isLoading = true;
-            try {
-                const response = await $fetch(`/api/reviews?productId=${productId}`);
-                this.reviews = response;
-            }
-            catch (error) {
-                console.error('Error fetching reviews:', error);
-            }
-            finally {
-                this.isLoading = false;
-            }
-        },
-        addReview(review) {
-            this.reviews.push(review);
-        }
-    }
-});

package/dist/composables/stores/storeInPickUp.d.ts

@@ -1 +0,0 @@
-export declare const useStoreInPickupStore: any;

package/dist/composables/stores/storeInPickUp.js

@@ -1,21 +0,0 @@
-import { defineStore } from 'pinia';
-export const useStoreInPickupStore = defineStore('storeInPickUp', {
-    state: () => ({
-        selectedStoreId: null,
-        stores: []
-    }),
-    actions: {
-        setSelectedStore(storeId) {
-            this.selectedStoreId = storeId;
-        },
-        async fetchStores() {
-            try {
-                const response = await $fetch('/api/stores');
-                this.stores = response;
-            }
-            catch (error) {
-                console.error('Error fetching stores:', error);
-            }
-        }
-    }
-});