arky-sdk 0.1.0

package/dist/stores/business.js

@@ -0,0 +1,122 @@
+// Unified Business Store - Single Source of Truth
+import { computed, deepMap } from "nanostores";
+import { BUSINESS_ID } from "../config";
+import * as authService from "../services/auth";
+import { getCurrencySymbol } from "../utils/currency";
+// Core business state
+export const businessStore = deepMap({
+    data: null,
+    loading: false,
+    error: null,
+    initialized: false,
+});
+// Computed values derived from business data
+export const selectedMarket = computed(businessStore, (state) => {
+    if (!state.data?.configs?.markets)
+        return null;
+    const markets = state.data.configs.markets;
+    // For arky website, always use 'us' market (hardcoded for headless)
+    return markets.find(m => m.id === 'us') ||
+        markets[0] ||
+        null;
+});
+export const currency = computed(selectedMarket, (market) => {
+    return market?.currency || 'USD';
+});
+export const currencySymbol = computed(selectedMarket, (market) => {
+    return getCurrencySymbol(market?.currency || 'USD');
+});
+export const markets = computed(businessStore, (state) => {
+    if (!state.data?.configs?.markets)
+        return [];
+    return state.data.configs.markets;
+});
+export const zones = computed(businessStore, (state) => {
+    if (!state.data?.configs?.zones)
+        return [];
+    return state.data.configs.zones;
+});
+// Get zone by country code
+export const getZoneByCountry = (countryCode) => {
+    const allZones = zones.get();
+    return allZones.find(zone => zone.countries.length === 0 || // Empty = all countries
+        zone.countries.includes(countryCode.toUpperCase())) || null;
+};
+// Get shipping methods for a specific country
+export const getShippingMethodsForCountry = (countryCode) => {
+    const zone = getZoneByCountry(countryCode);
+    return zone?.shippingMethods || [];
+};
+export const paymentMethods = computed(selectedMarket, (market) => {
+    if (!market)
+        return ['CASH'];
+    const methods = market.paymentMethods || [];
+    return methods.map((pm) => pm.method || pm);
+});
+export const paymentConfig = computed(businessStore, (state) => {
+    if (!state.data?.configs)
+        return { provider: null, enabled: false };
+    const provider = state.data.configs.paymentProvider || null;
+    const hasCreditCard = paymentMethods.get().includes('CREDIT_CARD');
+    return {
+        provider,
+        enabled: hasCreditCard && !!provider
+    };
+});
+export const orderBlocks = computed(businessStore, (state) => {
+    return state.data?.configs?.orderBlocks || [];
+});
+export const reservationBlocks = computed(businessStore, (state) => {
+    return state.data?.configs?.reservationBlocks || [];
+});
+// Actions
+export const businessActions = {
+    // Initialize business data - SINGLE API CALL for entire app
+    async init() {
+        const state = businessStore.get();
+        if (state.initialized && state.data) {
+            // Already loaded, skip
+            return;
+        }
+        try {
+            businessStore.setKey('loading', true);
+            businessStore.setKey('error', null);
+            const result = await authService.getBusinessConfig(BUSINESS_ID);
+            if (result.success) {
+                businessStore.setKey('data', result.data);
+                businessStore.setKey('initialized', true);
+            }
+            else {
+                throw new Error(result.error || 'Failed to load business configuration');
+            }
+        }
+        catch (error) {
+            businessStore.setKey('error', error.message);
+            console.error('Business store initialization failed:', error);
+        }
+        finally {
+            businessStore.setKey('loading', false);
+        }
+    },
+    // Reset store (useful for testing)
+    reset() {
+        businessStore.setKey('data', null);
+        businessStore.setKey('loading', false);
+        businessStore.setKey('error', null);
+        businessStore.setKey('initialized', false);
+    },
+    // Get business data (with auto-init)
+    async getBusiness() {
+        const state = businessStore.get();
+        if (!state.initialized || !state.data) {
+            await this.init();
+        }
+        return businessStore.get().data;
+    }
+};
+// Export everything for easy access
+export { businessStore as store, businessActions as actions };
+// Auto-initialize on first import (ensures data is always available)
+if (typeof window !== 'undefined') {
+    businessActions.init().catch(console.error);
+}

package/dist/stores/cart.d.ts

@@ -0,0 +1,8 @@
+export declare const totalCartItems: import("nanostores").ReadableAtom<number>;
+export declare const hasEshopItems: import("nanostores").ReadableAtom<boolean>;
+export declare const hasReservationItems: import("nanostores").ReadableAtom<boolean>;
+export declare const isCartEmpty: import("nanostores").ReadableAtom<boolean>;
+export declare const showEshopSection: import("nanostores").ReadableAtom<boolean>;
+export declare const showReservationSection: import("nanostores").ReadableAtom<boolean>;
+export declare const showBothSections: import("nanostores").ReadableAtom<boolean>;
+//# sourceMappingURL=cart.d.ts.map

package/dist/stores/cart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cart.d.ts","sourceRoot":"","sources":["../../src/stores/cart.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,2CAIzB,CAAC;AAGH,eAAO,MAAM,aAAa,4CAAqD,CAAC;AAChF,eAAO,MAAM,mBAAmB,4CAA2D,CAAC;AAC5F,eAAO,MAAM,WAAW,4CAEtB,CAAC;AAGH,eAAO,MAAM,gBAAgB,4CAAqF,CAAC;AACnH,eAAO,MAAM,sBAAsB,4CAAuG,CAAC;AAC3I,eAAO,MAAM,gBAAgB,4CAA2G,CAAC"}

package/dist/stores/cart.js

@@ -0,0 +1,20 @@
+// Unified cart store that manages both e-shop and reservation carts
+import { computed } from "nanostores";
+import { cartItems as eshopItems } from "./eshop";
+import { cartParts as reservationItems } from "./reservation";
+// Combined cart count
+export const totalCartItems = computed([eshopItems, reservationItems], (eshop, reservation) => {
+    const eshopCount = eshop?.reduce((sum, item) => sum + item.quantity, 0) || 0;
+    const reservationCount = reservation?.length || 0;
+    return eshopCount + reservationCount;
+});
+// Cart state helpers
+export const hasEshopItems = computed(eshopItems, (items) => items?.length > 0);
+export const hasReservationItems = computed(reservationItems, (items) => items?.length > 0);
+export const isCartEmpty = computed([eshopItems, reservationItems], (eshop, reservation) => {
+    return (!eshop || eshop.length === 0) && (!reservation || reservation.length === 0);
+});
+// Cart section visibility logic
+export const showEshopSection = computed([hasEshopItems, isCartEmpty], (hasEshop, isEmpty) => hasEshop || isEmpty);
+export const showReservationSection = computed([hasReservationItems, isCartEmpty], (hasReservation, isEmpty) => hasReservation || isEmpty);
+export const showBothSections = computed([hasEshopItems, hasReservationItems], (hasEshop, hasReservation) => hasEshop && hasReservation);

package/dist/stores/eshop.d.ts

@@ -0,0 +1,121 @@
+import { currency, paymentConfig, orderBlocks } from "./business";
+import type { EshopCartItem, Block, Price, Payment, Quote } from "../types";
+import { PaymentMethod } from "../types";
+export declare const cartItems: import("nanostores").WritableAtom<EshopCartItem[]>;
+export declare const promoCodeAtom: import("nanostores").PreinitializedWritableAtom<string> & object;
+export declare const quoteAtom: import("nanostores").PreinitializedWritableAtom<Quote> & object;
+export declare const store: import("nanostores").DeepMapStore<{
+    businessId: string;
+    selectedShippingMethodId: any;
+    shippingLocation: any;
+    userToken: any;
+    processingCheckout: boolean;
+    loading: boolean;
+    error: any;
+    phoneNumber: string;
+    phoneError: any;
+    verificationCode: string;
+    verifyError: any;
+    fetchingQuote: boolean;
+    quoteError: any;
+}>;
+export declare const cartTotal: import("nanostores").ReadableAtom<Payment>;
+export declare const cartItemCount: import("nanostores").ReadableAtom<number>;
+export { currency, paymentConfig, orderBlocks };
+export declare const allowedPaymentMethods: import("nanostores").ReadableAtom<any[]>;
+export declare const actions: {
+    addItem(product: any, variant: any, quantity?: number): void;
+    updateQuantity(itemId: string, newQuantity: number): void;
+    removeItem(itemId: string): void;
+    clearCart(): void;
+    getGuestToken(): Promise<string>;
+    prepareOrderItems(): {
+        productId: string;
+        variantId: string;
+        quantity: number;
+    }[];
+    getOrderInfoBlocks(): Block[];
+    checkout(paymentMethod?: PaymentMethod, orderInfoBlocks?: Block[], promoCode?: string | null): Promise<{
+        success: boolean;
+        error: string;
+        data?: undefined;
+    } | {
+        success: boolean;
+        data: {
+            orderId: any;
+            orderNumber: any;
+            clientSecret: any;
+        };
+        error?: undefined;
+    }>;
+    updateProfilePhone(): Promise<boolean>;
+    verifyPhoneCode(): Promise<boolean>;
+    formatPrice(priceOrPayment: Price | Payment): string;
+    getCartPayment(): Payment;
+    getAvailablePaymentMethods(): PaymentMethod[];
+    getShippingMethodsForCountry(countryCode: string): import("..").ShippingMethod[];
+    fetchQuote(promoCode?: string | null): Promise<void>;
+    applyPromoCode(code: string): Promise<void>;
+    removePromoCode(): Promise<void>;
+};
+export declare function initEshopStore(): void;
+declare const _default: {
+    store: import("nanostores").DeepMapStore<{
+        businessId: string;
+        selectedShippingMethodId: any;
+        shippingLocation: any;
+        userToken: any;
+        processingCheckout: boolean;
+        loading: boolean;
+        error: any;
+        phoneNumber: string;
+        phoneError: any;
+        verificationCode: string;
+        verifyError: any;
+        fetchingQuote: boolean;
+        quoteError: any;
+    }>;
+    actions: {
+        addItem(product: any, variant: any, quantity?: number): void;
+        updateQuantity(itemId: string, newQuantity: number): void;
+        removeItem(itemId: string): void;
+        clearCart(): void;
+        getGuestToken(): Promise<string>;
+        prepareOrderItems(): {
+            productId: string;
+            variantId: string;
+            quantity: number;
+        }[];
+        getOrderInfoBlocks(): Block[];
+        checkout(paymentMethod?: PaymentMethod, orderInfoBlocks?: Block[], promoCode?: string | null): Promise<{
+            success: boolean;
+            error: string;
+            data?: undefined;
+        } | {
+            success: boolean;
+            data: {
+                orderId: any;
+                orderNumber: any;
+                clientSecret: any;
+            };
+            error?: undefined;
+        }>;
+        updateProfilePhone(): Promise<boolean>;
+        verifyPhoneCode(): Promise<boolean>;
+        formatPrice(priceOrPayment: Price | Payment): string;
+        getCartPayment(): Payment;
+        getAvailablePaymentMethods(): PaymentMethod[];
+        getShippingMethodsForCountry(countryCode: string): import("..").ShippingMethod[];
+        fetchQuote(promoCode?: string | null): Promise<void>;
+        applyPromoCode(code: string): Promise<void>;
+        removePromoCode(): Promise<void>;
+    };
+    cartItems: import("nanostores").WritableAtom<EshopCartItem[]>;
+    cartTotal: import("nanostores").ReadableAtom<Payment>;
+    cartItemCount: import("nanostores").ReadableAtom<number>;
+    currency: import("nanostores").ReadableAtom<string>;
+    allowedPaymentMethods: import("nanostores").ReadableAtom<any[]>;
+    initEshopStore: typeof initEshopStore;
+};
+export default _default;
+//# sourceMappingURL=eshop.d.ts.map

package/dist/stores/eshop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eshop.d.ts","sourceRoot":"","sources":["../../src/stores/eshop.ts"],"names":[],"mappings":"AAOA,OAAO,EAEH,QAAQ,EAGR,aAAa,EACb,WAAW,EAEd,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,aAAa,EAAmB,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAC7F,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAIzC,eAAO,MAAM,SAAS,oDAGpB,CAAC;AAGH,eAAO,MAAM,aAAa,kEAA4B,CAAC;AAGvD,eAAO,MAAM,SAAS,iEAA2B,CAAC;AAGlD,eAAO,MAAM,KAAK;;;;;;;;;;;;;;EAgBhB,CAAC;AAGH,eAAO,MAAM,SAAS,4CAcpB,CAAC;AAEH,eAAO,MAAM,aAAa,2CAExB,CAAC;AAGH,OAAO,EACH,QAAQ,EACR,aAAa,EACb,WAAW,EACd,CAAC;AAGF,eAAO,MAAM,qBAAqB,0CAAiB,CAAC;AAGpD,eAAO,MAAM,OAAO;qBAEC,GAAG,WAAW,GAAG,aAAY,MAAM;2BAmD7B,MAAM,eAAe,MAAM;uBAS/B,MAAM;;qBAeF,OAAO,CAAC,MAAM,CAAC;;;;;;0BAoBhB,KAAK,EAAE;6BAKC,aAAa,oBAAyC,KAAK,EAAE,cAAc,MAAM,GAAG,IAAI;;;;;;;;;;;;;0BA+E1F,OAAO,CAAC,OAAO,CAAC;uBAenB,OAAO,CAAC,OAAO,CAAC;gCAgBb,KAAK,GAAG,OAAO,GAAG,MAAM;sBASlC,OAAO;kCAuBK,aAAa,EAAE;8CAKH,MAAM;2BAKnB,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;yBAyD/B,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;uBAMxB,OAAO,CAAC,IAAI,CAAC;CAIzC,CAAC;AAwBF,wBAAgB,cAAc,SAM7B;;;;;;;;;;;;;;;;;;yBA7VoB,GAAG,WAAW,GAAG,aAAY,MAAM;+BAmD7B,MAAM,eAAe,MAAM;2BAS/B,MAAM;;yBAeF,OAAO,CAAC,MAAM,CAAC;;;;;;8BAoBhB,KAAK,EAAE;iCAKC,aAAa,oBAAyC,KAAK,EAAE,cAAc,MAAM,GAAG,IAAI;;;;;;;;;;;;;8BA+E1F,OAAO,CAAC,OAAO,CAAC;2BAenB,OAAO,CAAC,OAAO,CAAC;oCAgBb,KAAK,GAAG,OAAO,GAAG,MAAM;0BASlC,OAAO;sCAuBK,aAAa,EAAE;kDAKH,MAAM;+BAKnB,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;6BAyD/B,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;2BAMxB,OAAO,CAAC,IAAI,CAAC;;;;;;;;;AAoC1C,wBASE"}

package/dist/stores/eshop.js

@@ -0,0 +1,377 @@
+// E-shop store with TypeScript - Simplified with Business Store
+import { atom, computed, deepMap } from "nanostores";
+import { persistentAtom } from "@nanostores/persistent";
+import { BUSINESS_ID } from "../config";
+import { eshopApi } from "../api/eshop";
+import { createPaymentForCheckout, getPriceAmount, formatPayment, formatMinor } from "../utils/price";
+import * as authService from "../services/auth";
+import { selectedMarket, currency, getShippingMethodsForCountry, paymentMethods, paymentConfig, orderBlocks, businessActions } from "./business";
+import { PaymentMethod } from "../types";
+// Toast notifications should be handled by UI layer
+// Frontend cart items
+export const cartItems = persistentAtom("eshopCart", [], {
+    encode: JSON.stringify,
+    decode: JSON.parse,
+});
+// Promo code state (not persisted - cleared on page reload)
+export const promoCodeAtom = atom(null);
+// Quote atom (fetched from backend)
+export const quoteAtom = atom(null);
+// Simplified store for cart-specific state only
+export const store = deepMap({
+    businessId: BUSINESS_ID,
+    selectedShippingMethodId: null, // Selected shipping method ID
+    shippingLocation: null, // Deprecated; kept for backward compat
+    userToken: null,
+    processingCheckout: false,
+    loading: false,
+    error: null,
+    // Phone verification
+    phoneNumber: "",
+    phoneError: null,
+    verificationCode: "",
+    verifyError: null,
+    // Quote fetching
+    fetchingQuote: false,
+    quoteError: null,
+});
+// Computed values using business store
+export const cartTotal = computed([cartItems, selectedMarket, currency], (items, market, curr) => {
+    // Return a Payment object with amounts in minor units
+    const subtotalMinor = (items || []).reduce((sum, item) => {
+        let amountMinor = 0;
+        if ('amount' in item.price) {
+            amountMinor = item.price.amount || 0;
+        }
+        return sum + (amountMinor * item.quantity);
+    }, 0);
+    const marketId = market?.id || 'us';
+    const currencyCode = curr || 'USD';
+    return createPaymentForCheckout(subtotalMinor, marketId, currencyCode, PaymentMethod.Cash);
+});
+export const cartItemCount = computed(cartItems, (items) => {
+    return items.reduce((sum, item) => sum + item.quantity, 0);
+});
+// Re-export business store computed values for convenience
+export { currency, paymentConfig, orderBlocks };
+// Create alias for backward compatibility
+export const allowedPaymentMethods = paymentMethods;
+// Actions
+export const actions = {
+    // Add item to cart
+    addItem(product, variant, quantity = 1) {
+        const items = cartItems.get();
+        const market = selectedMarket.get();
+        // Check if item already exists in cart
+        const existingItemIndex = items.findIndex((item) => item.productId === product.id && item.variantId === variant.id);
+        if (existingItemIndex !== -1) {
+            // Update existing item quantity
+            const updatedItems = [...items];
+            updatedItems[existingItemIndex].quantity += quantity;
+            cartItems.set(updatedItems);
+        }
+        else {
+            // Add new item with market-based pricing
+            let cartPrice;
+            if (variant.prices && Array.isArray(variant.prices)) {
+                // Market-based pricing from backend (amounts are minor units)
+                const marketCode = market?.id || 'us';
+                const marketAmount = getPriceAmount(variant.prices, marketCode);
+                cartPrice = {
+                    amount: marketAmount ?? 0,
+                    market: marketCode
+                };
+            }
+            else {
+                // Fallback
+                cartPrice = { amount: 0, market: market?.id || 'us' };
+            }
+            const newItem = {
+                id: crypto.randomUUID(),
+                productId: product.id,
+                variantId: variant.id,
+                productName: product.name,
+                productSlug: product.slug,
+                variantAttributes: variant.attributes || {},
+                price: cartPrice,
+                quantity,
+                addedAt: Date.now(),
+            };
+            cartItems.set([...items, newItem]);
+        }
+        // Toast notification should be handled by UI layer
+        // showToast(`${product.name} added to cart!`, "success", 3000);
+    },
+    // Update item quantity
+    updateQuantity(itemId, newQuantity) {
+        const items = cartItems.get();
+        const updatedItems = items.map((item) => item.id === itemId ? { ...item, quantity: Math.max(1, newQuantity) } : item);
+        cartItems.set(updatedItems);
+    },
+    // Remove item from cart
+    removeItem(itemId) {
+        const items = cartItems.get();
+        const updatedItems = items.filter((item) => item.id !== itemId);
+        cartItems.set(updatedItems);
+        // Toast notification should be handled by UI layer
+        // showToast("Item removed from cart!", "success", 2000);
+    },
+    // Clear entire cart
+    clearCart() {
+        cartItems.set([]);
+    },
+    // Get guest token
+    async getGuestToken() {
+        const state = store.get();
+        const token = await authService.getGuestToken(state.userToken);
+        if (token !== state.userToken) {
+            store.setKey("userToken", token);
+        }
+        return token;
+    },
+    // Prepare order items for checkout API
+    prepareOrderItems() {
+        const items = cartItems.get();
+        return items.map((item) => ({
+            productId: item.productId,
+            variantId: item.variantId,
+            quantity: item.quantity,
+        }));
+    },
+    // Get order info blocks (they already have values from DynamicForm)
+    getOrderInfoBlocks() {
+        return orderBlocks.get() || [];
+    },
+    // Process checkout - Updated to use Payment structure
+    async checkout(paymentMethod = PaymentMethod.Cash, orderInfoBlocks, promoCode) {
+        const items = cartItems.get();
+        if (!items.length) {
+            return { success: false, error: "Cart is empty" };
+        }
+        try {
+            store.setKey("processingCheckout", true);
+            store.setKey("error", null);
+            const token = await this.getGuestToken();
+            const orderItems = this.prepareOrderItems();
+            const blocks = orderInfoBlocks || this.getOrderInfoBlocks();
+            const state = store.get();
+            const market = selectedMarket.get();
+            if (!market) {
+                throw new Error("No market selected");
+            }
+            // Extract country code from location block
+            const locationBlock = blocks.find(b => b.key === 'location' && b.type === 'GEO_LOCATION');
+            const countryCode = locationBlock?.value?.[0]?.countryCode;
+            if (!countryCode) {
+                throw new Error("Country is required for checkout");
+            }
+            // Get available shipping methods for the country
+            const availableShippingMethods = getShippingMethodsForCountry(countryCode) || [];
+            if (!availableShippingMethods || availableShippingMethods.length === 0) {
+                throw new Error(`No shipping methods available for country: ${countryCode}`);
+            }
+            // Get selected shipping method or first available
+            const shippingMethodId = state.selectedShippingMethodId;
+            const shippingMethod = availableShippingMethods.find(sm => sm.id === shippingMethodId) ||
+                availableShippingMethods[0];
+            if (!shippingMethod) {
+                throw new Error("No shipping method available");
+            }
+            const promo = promoCode !== undefined ? promoCode : promoCodeAtom.get();
+            const response = await eshopApi.checkout({
+                token,
+                businessId: BUSINESS_ID,
+                items: orderItems,
+                paymentMethod: paymentMethod,
+                blocks,
+                market: market.id,
+                shippingMethodId: shippingMethod.id,
+                promoCode: promo || undefined,
+            });
+            if (response.success) {
+                return {
+                    success: true,
+                    data: {
+                        orderId: response.data.orderId,
+                        orderNumber: response.data.orderNumber,
+                        clientSecret: response.data.clientSecret,
+                    },
+                };
+            }
+            else {
+                throw new Error(response.error || "Failed to place order");
+            }
+        }
+        catch (err) {
+            const errorMessage = `Checkout failed: ${err.message}`;
+            store.setKey("error", errorMessage);
+            console.error("Checkout error:", err);
+            return { success: false, error: errorMessage };
+        }
+        finally {
+            store.setKey("processingCheckout", false);
+        }
+    },
+    // Phone verification for eshop
+    async updateProfilePhone() {
+        try {
+            const token = await this.getGuestToken();
+            const phoneNumber = store.get().phoneNumber;
+            await authService.updateProfilePhone(token, phoneNumber);
+            store.setKey("phoneError", null);
+            return true;
+        }
+        catch (error) {
+            console.error("Phone update error:", error);
+            store.setKey("phoneError", error.message);
+            return false;
+        }
+    },
+    async verifyPhoneCode() {
+        try {
+            const token = await this.getGuestToken();
+            const phoneNumber = store.get().phoneNumber;
+            const verificationCode = store.get().verificationCode;
+            await authService.verifyPhoneCode(token, phoneNumber, verificationCode);
+            store.setKey("verifyError", null);
+            return true;
+        }
+        catch (error) {
+            console.error("Phone verification error:", error);
+            store.setKey("verifyError", error.message);
+            return false;
+        }
+    },
+    formatPrice(priceOrPayment) {
+        const currencyCode = currency.get();
+        if ('total' in priceOrPayment) {
+            return formatPayment(priceOrPayment, { showSymbols: true, decimalPlaces: 2 });
+        }
+        return formatMinor(priceOrPayment.amount || 0, currencyCode);
+    },
+    getCartPayment() {
+        const items = cartItems.get();
+        const market = selectedMarket.get();
+        const currencyCode = currency.get();
+        const marketId = market?.id || 'us';
+        if (!items || items.length === 0) {
+            return createPaymentForCheckout(0, marketId, currencyCode, PaymentMethod.Cash);
+        }
+        const subtotalMinor = items.reduce((sum, item) => {
+            let amountMinor = 0;
+            if ('amount' in item.price) {
+                amountMinor = item.price.amount || 0;
+            }
+            return sum + (amountMinor * item.quantity);
+        }, 0);
+        return createPaymentForCheckout(subtotalMinor, marketId, currencyCode, PaymentMethod.Cash);
+    },
+    // Get available payment methods for selected market
+    getAvailablePaymentMethods() {
+        return paymentMethods.get() || [PaymentMethod.Cash];
+    },
+    // Get shipping methods for a country code
+    getShippingMethodsForCountry(countryCode) {
+        return getShippingMethodsForCountry(countryCode);
+    },
+    // Fetch quote from backend
+    async fetchQuote(promoCode) {
+        const items = cartItems.get();
+        const market = selectedMarket.get();
+        const currencyCode = currency.get();
+        const state = store.get();
+        const promo = promoCode !== undefined ? promoCode : promoCodeAtom.get();
+        if (!items || items.length === 0) {
+            quoteAtom.set(null);
+            return;
+        }
+        if (!market) {
+            console.error('No market selected for quote');
+            return;
+        }
+        try {
+            store.setKey('fetchingQuote', true);
+            store.setKey('quoteError', null);
+            const token = await this.getGuestToken();
+            const shippingMethodId = state.selectedShippingMethodId || undefined;
+            const response = await eshopApi.getQuote({
+                token,
+                businessId: BUSINESS_ID,
+                items: items.map(item => ({
+                    productId: item.productId,
+                    variantId: item.variantId,
+                    quantity: item.quantity,
+                })),
+                market: market.id,
+                currency: currencyCode,
+                userId: token,
+                paymentMethod: PaymentMethod.Cash,
+                shippingMethodId,
+                promoCode: promo || undefined,
+            });
+            if (response.success && response.data) {
+                quoteAtom.set(response.data);
+            }
+            else {
+                const friendly = mapQuoteError(response.code, response.error);
+                store.setKey('quoteError', friendly);
+                quoteAtom.set(null);
+            }
+        }
+        catch (error) {
+            console.error('Quote fetch error:', error);
+            store.setKey('quoteError', error.message);
+            quoteAtom.set(null);
+        }
+        finally {
+            store.setKey('fetchingQuote', false);
+        }
+    },
+    // Apply promo code
+    async applyPromoCode(code) {
+        promoCodeAtom.set(code);
+        await this.fetchQuote();
+    },
+    // Remove promo code
+    async removePromoCode() {
+        promoCodeAtom.set(null);
+        await this.fetchQuote();
+    },
+};
+function mapQuoteError(code, fallback) {
+    switch (code) {
+        case 'PROMO.MIN_ORDER':
+            return fallback || 'Promo requires a higher minimum order.';
+        case 'PROMO.NOT_ACTIVE':
+            return 'Promo code is not active.';
+        case 'PROMO.NOT_YET_VALID':
+            return 'Promo code is not yet valid.';
+        case 'PROMO.EXPIRED':
+            return 'Promo code has expired.';
+        case 'PROMO.MAX_USES':
+            return 'Promo code usage limit exceeded.';
+        case 'PROMO.MAX_USES_PER_USER':
+            return 'You have already used this promo code.';
+        case 'PROMO.NOT_FOUND':
+            return 'Promo code not found.';
+        default:
+            return fallback || 'Failed to fetch quote.';
+    }
+}
+// Initialize the store
+export function initEshopStore() {
+    // Initialize business data (if not already initialized)
+    businessActions.init();
+    // Note: Shipping method selection now happens after user enters shipping address
+    // and we determine their country → zone → available shipping methods
+}
+export default {
+    store,
+    actions,
+    cartItems,
+    cartTotal,
+    cartItemCount,
+    currency,
+    allowedPaymentMethods,
+    initEshopStore
+};

package/dist/stores/index.d.ts

@@ -0,0 +1,7 @@
+import { type ArkyConfig } from '../config';
+export { businessStore, businessActions, selectedMarket, currency, currencySymbol, markets, zones, getZoneByCountry, getShippingMethodsForCountry, paymentMethods, paymentConfig, orderBlocks, reservationBlocks } from './business';
+export { cartItems, cartTotal, cartItemCount, promoCodeAtom, quoteAtom, store as eshopStore, actions as eshopActions, initEshopStore, allowedPaymentMethods } from './eshop';
+export { cartParts, store as reservationStore, actions as reservationActions, initReservationStore, canProceed, currentStepName } from './reservation';
+export * from './cart';
+export declare function initArky(config: ArkyConfig): ArkyConfig;
+//# sourceMappingURL=index.d.ts.map

package/dist/stores/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/stores/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AAG7D,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAE,4BAA4B,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACrO,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,KAAK,IAAI,UAAU,EAAE,OAAO,IAAI,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAC7K,OAAO,EAAE,SAAS,EAAE,KAAK,IAAI,gBAAgB,EAAE,OAAO,IAAI,kBAAkB,EAAE,oBAAoB,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGvJ,cAAc,QAAQ,CAAC;AAGvB,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAUvD"}