arky-sdk 0.1.2 → 0.3.0

package/dist/stores.cjs

@@ -1,2148 +0,0 @@
-'use strict';
-
-var nanostores = require('nanostores');
-var persistent = require('@nanostores/persistent');
-
-// src/config.ts
-function setGlobalConfig(config) {
-  API_URL = config.apiUrl;
-  BUSINESS_ID = config.businessId;
-  STORAGE_URL = config.storageUrl || "";
-}
-var API_URL = "";
-var BUSINESS_ID = "";
-var STORAGE_URL = "";
-
-// src/utils/queryParams.ts
-function buildQueryString(params) {
-  const queryParts = [];
-  Object.entries(params).forEach(([key, value]) => {
-    if (value === null || value === void 0) {
-      return;
-    }
-    if (Array.isArray(value)) {
-      const jsonString = JSON.stringify(value);
-      queryParts.push(`${key}=${encodeURIComponent(jsonString)}`);
-    } else if (typeof value === "string") {
-      queryParts.push(`${key}=${encodeURIComponent(value)}`);
-    } else if (typeof value === "number" || typeof value === "boolean") {
-      queryParts.push(`${key}=${value}`);
-    } else if (typeof value === "object") {
-      const jsonString = JSON.stringify(value);
-      queryParts.push(`${key}=${encodeURIComponent(jsonString)}`);
-    }
-  });
-  return queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
-}
-function appendQueryString(url, params) {
-  const queryString = buildQueryString(params);
-  return queryString ? `${url}${queryString}` : url;
-}
-
-// src/services/http.ts
-async function get(url, options) {
-  try {
-    const finalUrl = options?.params ? appendQueryString(url, options.params) : url;
-    const response = await fetch(finalUrl);
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
-    }
-    const data = await response.json();
-    return {
-      value: data,
-      success: true
-    };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : "Unknown error occurred";
-    return {
-      value: null,
-      success: false,
-      error: errorMsg
-    };
-  }
-}
-async function post(url, data, options) {
-  try {
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(data)
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
-    }
-    const responseData = await response.json();
-    return {
-      value: responseData,
-      success: true
-    };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : "Unknown error occurred";
-    return {
-      value: null,
-      success: false,
-      error: errorMsg
-    };
-  }
-}
-var httpClient = {
-  get,
-  post
-};
-var http_default = httpClient;
-
-// src/api/reservation.ts
-var reservationApi = {
-  // Get quote for reservation parts
-  async getQuote({
-    token,
-    businessId,
-    market,
-    currency: currency2,
-    userId,
-    parts,
-    paymentMethod = "CASH",
-    promoCode
-  }) {
-    try {
-      const lines = parts.map((part) => ({
-        type: "SERVICE",
-        serviceId: part.serviceId,
-        quantity: 1
-      }));
-      const payload = {
-        businessId,
-        market,
-        currency: currency2,
-        userId,
-        paymentMethod,
-        lines,
-        promoCode: promoCode || void 0,
-        shippingMethodId: null
-      };
-      const res = await fetch(`${API_URL}/v1/payments/quote`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${token}`
-        },
-        body: JSON.stringify(payload)
-      });
-      const text = await res.text();
-      if (!res.ok) {
-        try {
-          const json = JSON.parse(text);
-          return { success: false, error: json.reason || json.error || "Failed to fetch quote", code: json.code };
-        } catch {
-          return { success: false, error: text || "Failed to fetch quote" };
-        }
-      }
-      const quote = text ? JSON.parse(text) : null;
-      return { success: true, data: quote };
-    } catch (e) {
-      return {
-        success: false,
-        error: e.message || "Failed to fetch quote"
-      };
-    }
-  },
-  // Get available slots for a service
-  async getAvailableSlots({
-    businessId,
-    serviceId,
-    from,
-    to,
-    limit = 1e3,
-    providerId = null
-  }) {
-    const url = `${API_URL}/v1/businesses/${businessId}/services/${serviceId}/available-slots`;
-    const response = await http_default.get(url, {
-      params: {
-        from,
-        to,
-        limit,
-        providerId
-      }
-    });
-    if (response.success) {
-      const json = response.value;
-      return {
-        success: true,
-        data: json.data?.items || json.items || []
-      };
-    } else {
-      console.error("Error fetching available slots:", response.error);
-      return {
-        success: false,
-        error: response.error,
-        data: []
-      };
-    }
-  },
-  // Get all providers for a service
-  async getProviders({ businessId, serviceId, limit = 50 }) {
-    const url = `${API_URL}/v1/businesses/${businessId}/providers`;
-    const response = await http_default.get(url, {
-      params: {
-        serviceId,
-        limit
-      }
-    });
-    if (response.success) {
-      const json = response.value;
-      return {
-        success: true,
-        data: json.items || []
-      };
-    } else {
-      console.error("Error loading providers:", response.error);
-      return {
-        success: false,
-        error: response.error,
-        data: []
-      };
-    }
-  },
-  // Get guest token or create a new one
-  async getGuestToken() {
-    try {
-      const res = await fetch(`${API_URL}/v1/users/login`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ provider: "GUEST" })
-      });
-      if (!res.ok) throw new Error("Guest login failed");
-      const json = await res.json();
-      return {
-        success: true,
-        data: { token: json.accessToken }
-      };
-    } catch (e) {
-      return {
-        success: false,
-        error: e.message
-      };
-    }
-  },
-  // Update user's phone number
-  async updateProfilePhone({ token, phoneNumber }) {
-    try {
-      const res = await fetch(`${API_URL}/v1/users/update`, {
-        method: "PUT",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify({
-          phoneNumber,
-          phoneNumbers: [],
-          addresses: []
-        })
-      });
-      if (!res.ok) {
-        const error = await res.text() || res.statusText;
-        return {
-          success: false,
-          error
-        };
-      }
-      return {
-        success: true
-      };
-    } catch (e) {
-      return {
-        success: false,
-        error: e.message
-      };
-    }
-  },
-  // Verify phone number with code
-  async verifyPhoneCode({ token, phoneNumber, code }) {
-    try {
-      const res = await fetch(`${API_URL}/v1/users/confirm/phone-number`, {
-        method: "PUT",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify({
-          phoneNumber,
-          code
-        })
-      });
-      if (!res.ok) {
-        const error = await res.text() || res.statusText;
-        return {
-          success: false,
-          error
-        };
-      }
-      return {
-        success: true
-      };
-    } catch (e) {
-      return {
-        success: false,
-        error: e.message
-      };
-    }
-  },
-  // Complete reservation checkout - Backend calculates currency from market
-  async checkout({
-    token,
-    businessId,
-    parts,
-    paymentMethod = "CASH",
-    blocks = [],
-    market = "US",
-    promoCode
-  }) {
-    try {
-      const payload = {
-        businessId,
-        blocks,
-        market,
-        parts: parts.map((p) => ({
-          serviceId: p.serviceId,
-          from: p.from,
-          to: p.to,
-          blocks: p.blocks,
-          reservationMethod: p.reservationMethod,
-          providerId: p.providerId
-        }))
-      };
-      if (paymentMethod !== void 0) {
-        payload.paymentMethod = paymentMethod;
-      }
-      if (promoCode) {
-        payload.promoCode = promoCode;
-      }
-      const res = await fetch(`${API_URL}/v1/reservations/checkout`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify(payload)
-      });
-      if (!res.ok) {
-        const error = await res.text() || res.statusText;
-        throw new Error(error);
-      }
-      const json = await res.json();
-      return {
-        success: true,
-        data: json
-        // Should include reservationId and clientSecret for payments
-      };
-    } catch (e) {
-      return {
-        success: false,
-        error: e.message
-      };
-    }
-  }
-};
-
-// src/services/auth.ts
-async function getGuestToken(currentToken = null) {
-  if (currentToken) return currentToken;
-  const response = await reservationApi.getGuestToken();
-  if (response.success && response.data) {
-    return response.data.token;
-  }
-  throw new Error("Failed to get guest token");
-}
-async function updateProfilePhone(token, phoneNumber) {
-  if (!phoneNumber) {
-    throw new Error("Phone number is required");
-  }
-  const response = await reservationApi.updateProfilePhone({ token, phoneNumber });
-  if (response.success) {
-    return { success: true };
-  } else {
-    throw new Error(response.error || "Failed to send verification code");
-  }
-}
-async function verifyPhoneCode(token, phoneNumber, code) {
-  if (!code) {
-    throw new Error("Verification code is required");
-  }
-  const response = await reservationApi.verifyPhoneCode({ token, phoneNumber, code });
-  if (response.success) {
-    return { success: true };
-  } else {
-    throw new Error(response.error || "Invalid verification code");
-  }
-}
-async function getBusinessConfig(businessId) {
-  try {
-    const response = await fetch(`${API_URL}/v1/businesses/${businessId}`, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to fetch business config: ${response.status}`);
-    }
-    const business = await response.json();
-    return {
-      success: true,
-      data: business
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error.message
-    };
-  }
-}
-
-// src/utils/currency.ts
-function getCurrencySymbol(currency2) {
-  const currencySymbols = {
-    USD: "$",
-    EUR: "\u20AC",
-    GBP: "\xA3",
-    CAD: "C$",
-    AUD: "A$",
-    JPY: "\xA5",
-    CHF: "CHF",
-    SEK: "kr",
-    NOK: "kr",
-    DKK: "kr",
-    PLN: "z\u0142",
-    CZK: "K\u010D",
-    HUF: "Ft",
-    RON: "lei",
-    BGN: "\u043B\u0432",
-    HRK: "kn",
-    RSD: "\u0434\u0438\u043D",
-    BAM: "KM",
-    MKD: "\u0434\u0435\u043D",
-    ALL: "L",
-    TRY: "\u20BA",
-    RUB: "\u20BD",
-    UAH: "\u20B4",
-    BYN: "Br",
-    CNY: "\xA5",
-    INR: "\u20B9",
-    KRW: "\u20A9",
-    THB: "\u0E3F",
-    VND: "\u20AB",
-    SGD: "S$",
-    MYR: "RM",
-    IDR: "Rp",
-    PHP: "\u20B1",
-    BRL: "R$",
-    ARS: "$",
-    CLP: "$",
-    COP: "$",
-    PEN: "S/",
-    MXN: "$",
-    ZAR: "R",
-    EGP: "E\xA3",
-    NGN: "\u20A6",
-    KES: "KSh",
-    GHS: "\u20B5",
-    MAD: "DH",
-    TND: "\u062F.\u062A",
-    DZD: "\u062F.\u062C",
-    LYD: "\u0644.\u062F",
-    AED: "\u062F.\u0625",
-    SAR: "\u0631.\u0633",
-    QAR: "\u0631.\u0642",
-    KWD: "\u062F.\u0643",
-    BHD: "\u0628.\u062F",
-    OMR: "\u0631.\u0639",
-    JOD: "\u062F.\u0623",
-    LBP: "\u0644.\u0644",
-    SYP: "\u0644.\u0633",
-    IQD: "\u0639.\u062F",
-    IRR: "\uFDFC",
-    AFN: "\u060B",
-    PKR: "\u20A8",
-    LKR: "\u20A8",
-    NPR: "\u20A8",
-    BDT: "\u09F3",
-    MMK: "K",
-    LAK: "\u20AD",
-    KHR: "\u17DB",
-    MNT: "\u20AE",
-    KZT: "\u20B8",
-    UZS: "\u043B\u0432",
-    KGS: "\u043B\u0432",
-    TJS: "SM",
-    TMT: "T",
-    AZN: "\u20BC",
-    GEL: "\u20BE",
-    AMD: "\u058F",
-    BYR: "p.",
-    MDL: "L"
-  };
-  return currencySymbols[currency2.toUpperCase()] || currency2;
-}
-
-// src/stores/business.ts
-var businessStore = nanostores.deepMap({
-  data: null,
-  loading: false,
-  error: null,
-  initialized: false
-});
-var selectedMarket = nanostores.computed(businessStore, (state) => {
-  if (!state.data?.configs?.markets) return null;
-  const markets2 = state.data.configs.markets;
-  return markets2.find((m) => m.id === "us") || markets2[0] || null;
-});
-var currency = nanostores.computed(selectedMarket, (market) => {
-  return market?.currency || "USD";
-});
-var currencySymbol = nanostores.computed(selectedMarket, (market) => {
-  return getCurrencySymbol(market?.currency || "USD");
-});
-var markets = nanostores.computed(businessStore, (state) => {
-  if (!state.data?.configs?.markets) return [];
-  return state.data.configs.markets;
-});
-var zones = nanostores.computed(businessStore, (state) => {
-  if (!state.data?.configs?.zones) return [];
-  return state.data.configs.zones;
-});
-var getZoneByCountry = (countryCode) => {
-  const allZones = zones.get();
-  return allZones.find(
-    (zone) => zone.countries.length === 0 || // Empty = all countries
-    zone.countries.includes(countryCode.toUpperCase())
-  ) || null;
-};
-var getShippingMethodsForCountry = (countryCode) => {
-  const zone = getZoneByCountry(countryCode);
-  return zone?.shippingMethods || [];
-};
-var paymentMethods = nanostores.computed(selectedMarket, (market) => {
-  if (!market) return ["CASH"];
-  const methods = market.paymentMethods || [];
-  return methods.map((pm) => pm.method || pm);
-});
-var paymentConfig = nanostores.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
-  };
-});
-var orderBlocks = nanostores.computed(businessStore, (state) => {
-  return state.data?.configs?.orderBlocks || [];
-});
-var reservationBlocks = nanostores.computed(businessStore, (state) => {
-  return state.data?.configs?.reservationBlocks || [];
-});
-var businessActions = {
-  // Initialize business data - SINGLE API CALL for entire app
-  async init() {
-    const state = businessStore.get();
-    if (state.initialized && state.data) {
-      return;
-    }
-    try {
-      businessStore.setKey("loading", true);
-      businessStore.setKey("error", null);
-      const result = await 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;
-  }
-};
-if (typeof window !== "undefined" && BUSINESS_ID) {
-  businessActions.init().catch(console.error);
-}
-
-// src/api/eshop.ts
-var eshopApi = {
-  // Get products
-  async getProducts({
-    businessId,
-    categoryIds = null,
-    status = "ACTIVE",
-    limit = 20,
-    cursor = null
-  }) {
-    const url = `${API_URL}/v1/businesses/${encodeURIComponent(businessId)}/products`;
-    const response = await http_default.get(url, {
-      params: {
-        categoryIds: categoryIds && categoryIds.length > 0 ? categoryIds : void 0,
-        status,
-        limit,
-        cursor
-      }
-    });
-    if (response.success) {
-      const json = response.value;
-      return {
-        success: true,
-        data: json.items || [],
-        cursor: json.cursor,
-        total: json.total || 0
-      };
-    } else {
-      console.error("Error fetching products:", response.error);
-      return {
-        success: false,
-        error: response.error,
-        data: []
-      };
-    }
-  },
-  // Get product by slug
-  async getProductBySlug({ businessId, slug }) {
-    try {
-      const url = `${API_URL}/v1/businesses/${encodeURIComponent(businessId)}/products/slug/${encodeURIComponent(businessId)}/${encodeURIComponent(slug)}`;
-      const res = await fetch(url);
-      if (!res.ok) throw new Error("Product not found");
-      const json = await res.json();
-      return {
-        success: true,
-        data: json
-      };
-    } catch (e) {
-      console.error("Error fetching product:", e);
-      return {
-        success: false,
-        error: e.message,
-        data: null
-      };
-    }
-  },
-  // Get quote for cart (pricing with promo codes, shipping, taxes)
-  async getQuote({
-    token,
-    businessId,
-    items,
-    market,
-    currency: currency2,
-    userId,
-    paymentMethod,
-    shippingMethodId,
-    promoCode
-  }) {
-    try {
-      const lines = items.map((item) => ({
-        type: "PRODUCT_VARIANT",
-        productId: item.productId,
-        variantId: item.variantId,
-        quantity: item.quantity
-      }));
-      const payload = {
-        businessId,
-        market,
-        currency: currency2,
-        userId,
-        paymentMethod,
-        lines,
-        ...shippingMethodId && { shippingMethodId },
-        ...promoCode && { promoCode }
-      };
-      const res = await fetch(`${API_URL}/v1/payments/quote`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify(payload)
-      });
-      const text = await res.text();
-      if (!res.ok) {
-        try {
-          const json = JSON.parse(text);
-          return { success: false, error: json.reason || json.error || res.statusText, code: json.code };
-        } catch {
-          return { success: false, error: text || res.statusText };
-        }
-      }
-      const quote = text ? JSON.parse(text) : null;
-      return { success: true, data: quote };
-    } catch (e) {
-      console.error("Quote fetch failed:", e);
-      return {
-        success: false,
-        error: e.message
-      };
-    }
-  },
-  // Checkout - Backend calculates currency from market
-  async checkout({
-    token,
-    businessId,
-    items,
-    paymentMethod,
-    blocks,
-    market = "US",
-    shippingMethodId,
-    promoCode,
-    paymentIntentId = null
-  }) {
-    try {
-      const payload = {
-        businessId,
-        items,
-        paymentMethod,
-        blocks,
-        market,
-        ...shippingMethodId && { shippingMethodId },
-        ...promoCode && { promoCode },
-        ...paymentIntentId && { paymentIntentId }
-      };
-      const res = await fetch(`${API_URL}/v1/businesses/${encodeURIComponent(businessId)}/orders/checkout`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify(payload)
-      });
-      const text = await res.text();
-      if (!res.ok) {
-        try {
-          const json2 = JSON.parse(text);
-          return { success: false, error: json2.reason || json2.error || res.statusText, code: json2.code };
-        } catch {
-          return { success: false, error: text || res.statusText };
-        }
-      }
-      const json = text ? JSON.parse(text) : null;
-      return { success: true, data: json };
-    } catch (e) {
-      return {
-        success: false,
-        error: e.message
-      };
-    }
-  },
-  // Create payment intent for Stripe
-  async createPaymentIntent({ amount, currency: currency2, businessId }) {
-    try {
-      const tokenResponse = await reservationApi.getGuestToken();
-      if (!tokenResponse.success || !tokenResponse.data) {
-        throw new Error("Failed to get guest token");
-      }
-      const token = tokenResponse.data.token;
-      const res = await fetch(`${API_URL}/v1/businesses/${encodeURIComponent(businessId)}/payment/create-intent`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${token}`
-        },
-        body: JSON.stringify({
-          amount,
-          currency: currency2,
-          businessId
-        })
-      });
-      if (!res.ok) {
-        const error = await res.text() || res.statusText;
-        throw new Error(error);
-      }
-      const json = await res.json();
-      return {
-        success: true,
-        data: json
-      };
-    } catch (e) {
-      console.error("Payment intent creation failed:", e);
-      return {
-        success: false,
-        error: e.message
-      };
-    }
-  }
-};
-
-// src/utils/price.ts
-var CURRENCY_SYMBOLS = {
-  "USD": "$",
-  "EUR": "\u20AC",
-  "GBP": "\xA3",
-  "CAD": "C$",
-  "AUD": "A$"
-};
-var MARKET_CURRENCIES = {
-  "US": "USD",
-  "EU": "EUR",
-  "UK": "GBP",
-  "CA": "CAD",
-  "AU": "AUD"
-};
-function convertToMajor(minorAmount) {
-  return (minorAmount ?? 0) / 100;
-}
-function getSymbol(currency2) {
-  return CURRENCY_SYMBOLS[currency2] || "$";
-}
-function getCurrencyFromMarket(marketId) {
-  return MARKET_CURRENCIES[marketId] || "USD";
-}
-function formatCurrencyAmount(amount, currency2, options = {}) {
-  const { showSymbols = true, decimalPlaces = 2, customSymbol } = options;
-  const roundedAmount = amount.toFixed(decimalPlaces);
-  if (!showSymbols) {
-    return `${roundedAmount} ${currency2}`;
-  }
-  const symbol = customSymbol || getSymbol(currency2);
-  return `${symbol}${roundedAmount}`;
-}
-function formatMinor(amountMinor, currency2, options = {}) {
-  const major = convertToMajor(amountMinor);
-  return formatCurrencyAmount(major, currency2, options);
-}
-function formatPayment(payment, options = {}) {
-  if (!payment) return "";
-  const { showSymbols = true, decimalPlaces = 2, showBreakdown = false } = options;
-  if (showBreakdown) {
-    const subtotal = formatMinor(payment.subtotal, payment.currency, { showSymbols, decimalPlaces });
-    const discount = (payment.discount ?? 0) > 0 ? formatMinor(payment.discount, payment.currency, { showSymbols, decimalPlaces }) : null;
-    const tax = (payment.tax ?? 0) > 0 ? formatMinor(payment.tax, payment.currency, { showSymbols, decimalPlaces }) : null;
-    const total = formatMinor(payment.total, payment.currency, { showSymbols, decimalPlaces });
-    let result = `Subtotal: ${subtotal}`;
-    if (discount) result += `, Discount: -${discount}`;
-    if (tax) result += `, Tax: ${tax}`;
-    result += `, Total: ${total}`;
-    return result;
-  }
-  return formatMinor(payment.total, payment.currency, { showSymbols, decimalPlaces });
-}
-function getMarketPrice(prices, marketId, businessMarkets, options = {}) {
-  if (!prices || prices.length === 0) return "";
-  const {
-    showSymbols = true,
-    decimalPlaces = 2,
-    showCompareAt = true,
-    fallbackMarket = "US"
-  } = options;
-  let price = prices.find((p) => p.market === marketId);
-  if (!price) {
-    price = prices.find((p) => p.market === fallbackMarket) || prices[0];
-  }
-  if (!price) return "";
-  let currency2;
-  let symbol;
-  {
-    currency2 = getCurrencyFromMarket(price.market);
-    symbol = getSymbol(currency2);
-  }
-  const formattedPrice = formatMinor(price.amount ?? 0, currency2, {
-    showSymbols,
-    decimalPlaces,
-    customSymbol: symbol
-  });
-  if (showCompareAt && price.compareAt && price.compareAt > (price.amount ?? 0)) {
-    const formattedCompareAt = formatMinor(price.compareAt, currency2, {
-      showSymbols,
-      decimalPlaces,
-      customSymbol: symbol
-    });
-    return `${formattedPrice} was ${formattedCompareAt}`;
-  }
-  return formattedPrice;
-}
-function getPriceAmount(prices, marketId, fallbackMarket = "US") {
-  if (!prices || prices.length === 0) return 0;
-  const price = prices.find((p) => p.market === marketId) || prices.find((p) => p.market === fallbackMarket) || prices[0];
-  return price?.amount || 0;
-}
-function createPaymentForCheckout(subtotalMinor, marketId, currency2, paymentMethod, options = {}) {
-  const { discount = 0, tax = 0, promoCodeId } = options;
-  const total = subtotalMinor - discount + tax;
-  return {
-    currency: currency2,
-    market: marketId,
-    subtotal: subtotalMinor,
-    shipping: 0,
-    discount,
-    tax,
-    total,
-    promoCodeId,
-    method: paymentMethod
-  };
-}
-
-// src/stores/eshop.ts
-var cartItems = persistent.persistentAtom("eshopCart", [], {
-  encode: JSON.stringify,
-  decode: JSON.parse
-});
-var promoCodeAtom = nanostores.atom(null);
-var quoteAtom = nanostores.atom(null);
-var store = nanostores.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
-});
-var cartTotal = nanostores.computed([cartItems, selectedMarket, currency], (items, market, curr) => {
-  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, "CASH" /* Cash */);
-});
-var cartItemCount = nanostores.computed(cartItems, (items) => {
-  return items.reduce((sum, item) => sum + item.quantity, 0);
-});
-var allowedPaymentMethods = paymentMethods;
-var actions = {
-  // Add item to cart
-  addItem(product, variant, quantity = 1) {
-    const items = cartItems.get();
-    const market = selectedMarket.get();
-    const existingItemIndex = items.findIndex(
-      (item) => item.productId === product.id && item.variantId === variant.id
-    );
-    if (existingItemIndex !== -1) {
-      const updatedItems = [...items];
-      updatedItems[existingItemIndex].quantity += quantity;
-      cartItems.set(updatedItems);
-    } else {
-      let cartPrice;
-      if (variant.prices && Array.isArray(variant.prices)) {
-        const marketCode = market?.id || "us";
-        const marketAmount = getPriceAmount(variant.prices, marketCode);
-        cartPrice = {
-          amount: marketAmount ?? 0,
-          market: marketCode
-        };
-      } else {
-        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]);
-    }
-  },
-  // 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);
-  },
-  // Clear entire cart
-  clearCart() {
-    cartItems.set([]);
-  },
-  // Get guest token
-  async getGuestToken() {
-    const state = store.get();
-    const token = await 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 = "CASH" /* 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");
-      }
-      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");
-      }
-      const availableShippingMethods = getShippingMethodsForCountry(countryCode) || [];
-      if (!availableShippingMethods || availableShippingMethods.length === 0) {
-        throw new Error(`No shipping methods available for country: ${countryCode}`);
-      }
-      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 !== void 0 ? promoCode : promoCodeAtom.get();
-      const response = await eshopApi.checkout({
-        token,
-        businessId: BUSINESS_ID,
-        items: orderItems,
-        paymentMethod,
-        blocks,
-        market: market.id,
-        shippingMethodId: shippingMethod.id,
-        promoCode: promo || void 0
-      });
-      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 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 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, "CASH" /* 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, "CASH" /* Cash */);
-  },
-  // Get available payment methods for selected market
-  getAvailablePaymentMethods() {
-    return paymentMethods.get() || ["CASH" /* 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 !== void 0 ? 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 || void 0;
-      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: "CASH" /* Cash */,
-        shippingMethodId,
-        promoCode: promo || void 0
-      });
-      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.";
-  }
-}
-function initEshopStore() {
-  businessActions.init();
-}
-
-// src/utils/i18n.ts
-var defaultLocale = "en";
-function getLocale() {
-  if (typeof window !== "undefined" && window.navigator) {
-    return window.navigator.language.split("-")[0] || defaultLocale;
-  }
-  return defaultLocale;
-}
-function getLocalizedString(value, locale) {
-  if (!value) return "";
-  if (typeof value === "string") return value;
-  if (typeof value === "object") {
-    const targetLocale = locale || getLocale();
-    return value[targetLocale] || value["en"] || value[Object.keys(value)[0]] || "";
-  }
-  return String(value);
-}
-
-// src/utils/validation.ts
-function validatePhoneNumber(phone) {
-  if (!phone) {
-    return { isValid: false, error: "Phone number is required" };
-  }
-  const cleaned = phone.replace(/\D/g, "");
-  if (cleaned.length < 8) {
-    return { isValid: false, error: "Phone number is too short" };
-  }
-  if (cleaned.length > 15) {
-    return { isValid: false, error: "Phone number is too long" };
-  }
-  return { isValid: true };
-}
-
-// src/utils/timezone.ts
-var tzGroups = [
-  {
-    label: "US",
-    zones: [
-      { label: "Eastern Time", value: "America/New_York" },
-      { label: "Central Time", value: "America/Chicago" },
-      { label: "Mountain Time", value: "America/Denver" },
-      { label: "Pacific Time", value: "America/Los_Angeles" }
-    ]
-  },
-  {
-    label: "Europe",
-    zones: [
-      { label: "London", value: "Europe/London" },
-      { label: "Paris", value: "Europe/Paris" },
-      { label: "Berlin", value: "Europe/Berlin" },
-      { label: "Rome", value: "Europe/Rome" }
-    ]
-  },
-  {
-    label: "Asia",
-    zones: [
-      { label: "Tokyo", value: "Asia/Tokyo" },
-      { label: "Shanghai", value: "Asia/Shanghai" },
-      { label: "Mumbai", value: "Asia/Kolkata" },
-      { label: "Dubai", value: "Asia/Dubai" }
-    ]
-  }
-];
-function findTimeZone(groups) {
-  try {
-    const detected = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    for (const group of groups) {
-      for (const zone of group.zones) {
-        if (zone.value === detected) {
-          return detected;
-        }
-      }
-    }
-    return "UTC";
-  } catch (e) {
-    return "UTC";
-  }
-}
-
-// src/stores/reservation.ts
-var cartParts = persistent.persistentAtom("reservationCart", [], {
-  encode: JSON.stringify,
-  decode: JSON.parse
-});
-var store2 = nanostores.deepMap({
-  currentStep: 1,
-  totalSteps: 4,
-  steps: {
-    1: { name: "method", labelKey: "method" },
-    2: { name: "provider", labelKey: "provider" },
-    3: { name: "datetime", labelKey: "datetime" },
-    4: { name: "review", labelKey: "review" }
-  },
-  // Calendar data
-  weekdays: ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
-  monthYear: "",
-  days: [],
-  current: /* @__PURE__ */ new Date(),
-  // Selection state
-  selectedDate: null,
-  slots: [],
-  selectedSlot: null,
-  selectedMethod: null,
-  selectedProvider: null,
-  providers: [],
-  // Status flags
-  loading: false,
-  startDate: null,
-  endDate: null,
-  isMultiDay: false,
-  // Phone verification
-  phoneNumber: "",
-  phoneError: null,
-  phoneSuccess: null,
-  verificationCode: "",
-  verifyError: null,
-  isPhoneVerified: false,
-  isSendingCode: false,
-  isVerifying: false,
-  codeSentAt: null,
-  canResendAt: null,
-  // Quote state
-  fetchingQuote: false,
-  quote: null,
-  quoteError: null,
-  // Service & config
-  guestToken: null,
-  service: null,
-  apiUrl: API_URL,
-  businessId: BUSINESS_ID,
-  storageUrl: STORAGE_URL,
-  timezone: findTimeZone(tzGroups),
-  tzGroups,
-  parts: []
-});
-var currentStepName = nanostores.computed(store2, (state) => {
-  return state?.steps?.[state?.currentStep]?.name || "";
-});
-var canProceed = nanostores.computed(store2, (state) => {
-  const stepName = state?.steps?.[state?.currentStep]?.name;
-  switch (stepName) {
-    case "method":
-      return !!state.selectedMethod;
-    case "provider":
-      return !!state.selectedProvider;
-    case "datetime":
-      return state.isMultiDay ? !!(state.startDate && state.endDate && state.selectedSlot) : !!(state.selectedDate && state.selectedSlot);
-    case "review":
-      return true;
-    default:
-      return false;
-  }
-});
-var createCalendarGrid = (date) => {
-  const first = new Date(date.getFullYear(), date.getMonth(), 1);
-  const last = new Date(date.getFullYear(), date.getMonth() + 1, 0);
-  const cells = [];
-  const pad = (first.getDay() + 6) % 7;
-  for (let i = 0; i < pad; i++) cells.push({ key: `b-${i}`, blank: true });
-  for (let d = 1; d <= last.getDate(); d++) {
-    cells.push({
-      key: `d-${d}`,
-      blank: false,
-      date: new Date(date.getFullYear(), date.getMonth(), d),
-      available: false
-    });
-  }
-  const suffix = (7 - cells.length % 7) % 7;
-  for (let i = 0; i < suffix; i++) cells.push({ key: `b2-${i}`, blank: true });
-  return cells;
-};
-var formatTimeSlot = (from, to, timezone) => {
-  const opts = { hour: "2-digit", minute: "2-digit", timeZone: timezone };
-  return `${new Date(from * 1e3).toLocaleTimeString([], opts)} \u2013 ${new Date(to * 1e3).toLocaleTimeString([], opts)}`;
-};
-var actions2 = {
-  // Calendar management
-  updateCalendarGrid() {
-    const state = store2.get();
-    const cur = state.current || new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), 1);
-    const days = createCalendarGrid(cur);
-    store2.setKey("current", cur);
-    store2.setKey("monthYear", cur.toLocaleString(void 0, { month: "long", year: "numeric" }));
-    store2.setKey("days", days);
-  },
-  updateCalendar() {
-    this.updateCalendarGrid();
-    const state = store2.get();
-    if (state.service) this.fetchAvailability("month");
-  },
-  prevMonth() {
-    const { current } = store2.get();
-    store2.setKey("current", new Date(current.getFullYear(), current.getMonth() - 1, 1));
-    this.updateCalendar();
-  },
-  nextMonth() {
-    const { current } = store2.get();
-    store2.setKey("current", new Date(current.getFullYear(), current.getMonth() + 1, 1));
-    this.updateCalendar();
-  },
-  // Service initialization
-  setService(service) {
-    store2.setKey("service", service);
-    store2.setKey("selectedMethod", null);
-    store2.setKey("selectedProvider", null);
-    store2.setKey("providers", []);
-    store2.setKey("selectedDate", null);
-    store2.setKey("startDate", null);
-    store2.setKey("endDate", null);
-    store2.setKey("slots", []);
-    store2.setKey("selectedSlot", null);
-    store2.setKey("currentStep", 1);
-    store2.setKey("isMultiDay", !!service?.reservationConfigs?.isMultiDay);
-    const now = /* @__PURE__ */ new Date();
-    store2.setKey("current", new Date(now.getFullYear(), now.getMonth(), 1));
-    this.updateCalendarGrid();
-    if (service.reservationMethods?.length === 1) {
-      const method = service.reservationMethods[0];
-      store2.setKey("selectedMethod", method);
-      this.determineTotalSteps();
-      this.handleMethodSelection(method, false);
-    } else {
-      this.determineTotalSteps();
-    }
-    this.fetchAvailability("month");
-  },
-  // Step management
-  determineTotalSteps() {
-    const state = store2.get();
-    if (!state.service) {
-      store2.setKey("totalSteps", 1);
-      return 1;
-    }
-    const active = [];
-    if (state.service.reservationMethods?.length > 1) {
-      active.push({ name: "method", label: "Choose Reservation Type" });
-    }
-    if (state.selectedMethod?.includes("SPECIFIC")) {
-      active.push({ name: "provider", label: "Choose Provider" });
-    }
-    if (state.selectedMethod && state.selectedMethod !== "ORDER") {
-      active.push({
-        name: "datetime",
-        label: state.isMultiDay ? "Choose Date Range" : "Choose Date & Time"
-      });
-    }
-    active.push({ name: "review", label: "Review & Confirm" });
-    const stepObj = {};
-    active.forEach((st, idx) => {
-      stepObj[idx + 1] = st;
-    });
-    store2.setKey("steps", stepObj);
-    store2.setKey("totalSteps", active.length);
-    if (state.currentStep > active.length) {
-      store2.setKey("currentStep", active.length);
-    }
-    return active.length;
-  },
-  async getGuestToken() {
-    const state = store2.get();
-    const token = await getGuestToken(state.guestToken);
-    if (token !== state.guestToken) {
-      store2.setKey("guestToken", token);
-    }
-    return token;
-  },
-  getStepNumberByName(name) {
-    const { steps } = store2.get();
-    for (const [k, v] of Object.entries(steps)) {
-      if (v.name === name) return Number(k);
-    }
-    return null;
-  },
-  nextStep() {
-    const state = store2.get();
-    if (state.currentStep >= state.totalSteps || !canProceed.get()) return;
-    const next = state.currentStep + 1;
-    const name = state.steps[next]?.name;
-    store2.setKey("currentStep", next);
-    if (name === "datetime") {
-      this.fetchAvailability("month");
-      if (!state.selectedDate && !state.startDate) {
-        this.findFirstAvailable();
-      }
-    }
-  },
-  prevStep() {
-    const state = store2.get();
-    if (state.currentStep <= 1) return;
-    this.clearCurrentStepState();
-    store2.setKey("currentStep", state.currentStep - 1);
-  },
-  clearCurrentStepState() {
-    const name = currentStepName.get();
-    if (name === "method") {
-      store2.setKey("selectedMethod", null);
-    } else if (name === "provider") {
-      store2.setKey("selectedProvider", null);
-      store2.setKey("providers", []);
-    } else if (name === "datetime") {
-      store2.setKey("selectedDate", null);
-      store2.setKey("startDate", null);
-      store2.setKey("endDate", null);
-      store2.setKey("slots", []);
-      store2.setKey("selectedSlot", null);
-    }
-  },
-  goToStep(step) {
-    const state = store2.get();
-    if (step < 1 || step > state.totalSteps) return;
-    if (step < state.currentStep) {
-      for (let i = state.currentStep; i > step; i--) {
-        const n = state.steps[i]?.name;
-        if (n === "datetime") {
-          store2.setKey("selectedDate", null);
-          store2.setKey("startDate", null);
-          store2.setKey("endDate", null);
-          store2.setKey("slots", []);
-          store2.setKey("selectedSlot", null);
-        } else if (n === "provider") {
-          store2.setKey("selectedProvider", null);
-          store2.setKey("providers", []);
-        } else if (n === "method") {
-          store2.setKey("selectedMethod", null);
-        }
-      }
-    }
-    store2.setKey("currentStep", step);
-    if (state.steps[step]?.name === "datetime") {
-      this.fetchAvailability("month");
-      if (!state.selectedDate && !state.startDate) {
-        this.findFirstAvailable();
-      }
-    }
-  },
-  // Method selection
-  async handleMethodSelection(method, advance = true) {
-    store2.setKey("selectedDate", null);
-    store2.setKey("startDate", null);
-    store2.setKey("endDate", null);
-    store2.setKey("slots", []);
-    store2.setKey("selectedSlot", null);
-    store2.setKey("selectedMethod", method);
-    this.determineTotalSteps();
-    if (method === "ORDER") {
-      this.handleOrderMethod();
-      if (advance) {
-        const reviewStep = this.getStepNumberByName("review");
-        if (reviewStep) this.goToStep(reviewStep);
-        return;
-      }
-    } else if (method.includes("SPECIFIC")) {
-      await this.loadProviders();
-      const state = store2.get();
-      if (advance && state.providers.length === 1) {
-        this.selectProvider(state.providers[0]);
-        const datetimeStep = this.getStepNumberByName("datetime");
-        if (datetimeStep) this.goToStep(datetimeStep);
-        return;
-      }
-    } else if (method === "STANDARD" && advance) {
-      const datetimeStep = this.getStepNumberByName("datetime");
-      if (datetimeStep) this.goToStep(datetimeStep);
-      return;
-    }
-    if (advance && store2.get().currentStep < store2.get().totalSteps) {
-      this.nextStep();
-    }
-  },
-  handleOrderMethod() {
-    const state = store2.get();
-    const now = /* @__PURE__ */ new Date();
-    const dur = state.service.durations?.reduce((a, c) => a + c.duration, 0) || 3600;
-    const from = Math.floor(now.getTime() / 1e3);
-    const to = from + dur;
-    store2.setKey("selectedSlot", {
-      from,
-      to,
-      timeText: formatTimeSlot(from, to, state.timezone)
-    });
-  },
-  // Provider management
-  async loadProviders() {
-    store2.setKey("loading", true);
-    store2.setKey("providers", []);
-    try {
-      const { businessId, service } = store2.get();
-      const res = await reservationApi.getProviders({ businessId, serviceId: service.id });
-      store2.setKey("providers", res.success ? res.data : []);
-    } catch (e) {
-      console.error("Error loading providers:", e);
-    } finally {
-      store2.setKey("loading", false);
-    }
-  },
-  selectProvider(provider) {
-    store2.setKey("selectedProvider", provider);
-    store2.setKey("selectedDate", null);
-    store2.setKey("startDate", null);
-    store2.setKey("endDate", null);
-    store2.setKey("slots", []);
-    store2.setKey("selectedSlot", null);
-    if (currentStepName.get() === "datetime") {
-      this.fetchAvailability("month");
-      this.findFirstAvailable();
-    }
-  },
-  // Availability and date management
-  async fetchAvailability(type, date = null) {
-    const state = store2.get();
-    if (!state.service || currentStepName.get() !== "datetime") return;
-    store2.setKey("loading", true);
-    try {
-      let from, to, limit;
-      if (type === "month") {
-        from = Math.floor(
-          new Date(state.current.getFullYear(), state.current.getMonth(), 1).getTime() / 1e3
-        );
-        to = Math.floor(
-          new Date(state.current.getFullYear(), state.current.getMonth() + 1, 0).getTime() / 1e3
-        );
-        limit = 100;
-      } else if (type === "day" && date) {
-        const dObj = typeof date === "string" ? new Date(date) : date;
-        from = Math.floor(dObj.getTime() / 1e3);
-        to = from + 24 * 3600;
-        limit = 100;
-      } else if (type === "first") {
-        const now = /* @__PURE__ */ new Date();
-        from = Math.floor(now.setHours(0, 0, 0, 0) / 1e3);
-        to = Math.floor(new Date(now.getFullYear(), now.getMonth() + 3, 0).getTime() / 1e3);
-        limit = 1;
-      } else {
-        store2.setKey("loading", false);
-        return;
-      }
-      const params = { businessId: state.businessId, serviceId: state.service.id, from, to, limit };
-      if (state.selectedProvider) params.providerId = state.selectedProvider.id;
-      const result = await reservationApi.getAvailableSlots(params);
-      if (!result.success) {
-        console.error(`Error fetching availability (${type}):`, result.error);
-        return;
-      }
-      if (type === "month") {
-        const avail = new Set(
-          result.data.map((i) => {
-            const date2 = new Date(i.from * 1e3);
-            return date2.toISOString().slice(0, 10);
-          })
-        );
-        store2.setKey(
-          "days",
-          state.days.map((c) => {
-            if (!c.blank && c.date) {
-              const iso = c.date.toISOString().slice(0, 10);
-              return { ...c, available: avail.has(iso) };
-            }
-            return c;
-          })
-        );
-      } else if (type === "day") {
-        const slots = result.data.map((i, idx) => ({
-          ...i,
-          id: `slot-${i.from}-${idx}`,
-          day: new Date(i.from * 1e3).toISOString().slice(0, 10),
-          timeText: formatTimeSlot(i.from, i.to, state.timezone)
-        }));
-        store2.setKey("slots", slots);
-        if (slots.length && !state.selectedSlot) {
-          store2.setKey("selectedSlot", slots[0]);
-        }
-      } else if (type === "first" && result.data.length) {
-        const first = new Date(result.data[0].from * 1e3);
-        const iso = first.toISOString().slice(0, 10);
-        store2.setKey("current", new Date(first.getFullYear(), first.getMonth(), 1));
-        this.updateCalendarGrid();
-        await this.fetchAvailability("month");
-        if (state.isMultiDay) {
-          store2.setKey("startDate", iso);
-          store2.setKey("selectedDate", iso);
-        } else {
-          store2.setKey("selectedDate", iso);
-          await this.fetchAvailability("day", iso);
-        }
-      }
-    } catch (err) {
-      console.error(`Error in fetchAvailability (${type}):`, err);
-    } finally {
-      store2.setKey("loading", false);
-    }
-  },
-  findFirstAvailable() {
-    if (currentStepName.get() === "datetime") this.fetchAvailability("first");
-  },
-  // Date selection
-  selectDate(cell) {
-    if (!cell.date || !cell.available) return;
-    const dateInfo = {
-      year: cell.date.getFullYear(),
-      month: cell.date.getMonth() + 1,
-      day: cell.date.getDate(),
-      iso: `${cell.date.getFullYear()}-${String(cell.date.getMonth() + 1).padStart(2, "0")}-${String(cell.date.getDate()).padStart(2, "0")}`
-    };
-    const state = store2.get();
-    if (state.isMultiDay) {
-      if (!state.startDate) {
-        store2.setKey("startDate", dateInfo.iso);
-        store2.setKey("selectedSlot", null);
-        store2.setKey("selectedDate", dateInfo.iso);
-        store2.setKey("endDate", null);
-      } else if (!state.endDate) {
-        const start = new Date(state.startDate).getTime();
-        const cellT = cell.date.getTime();
-        if (cellT < start) {
-          store2.setKey("endDate", state.startDate);
-          store2.setKey("startDate", dateInfo.iso);
-        } else {
-          store2.setKey("endDate", dateInfo.iso);
-        }
-      } else {
-        store2.setKey("startDate", dateInfo.iso);
-        store2.setKey("selectedDate", dateInfo.iso);
-        store2.setKey("endDate", null);
-        store2.setKey("selectedSlot", null);
-      }
-    } else {
-      store2.setKey("selectedSlot", null);
-      store2.setKey("selectedDate", dateInfo.iso);
-      this.fetchAvailability("day", dateInfo.iso);
-    }
-  },
-  createMultiDaySlot() {
-    const state = store2.get();
-    if (!state.startDate || !state.endDate) return;
-    const startDT = new Date(state.startDate);
-    startDT.setHours(9, 0, 0, 0);
-    const endDT = new Date(state.endDate);
-    endDT.setHours(17, 0, 0, 0);
-    const from = Math.floor(startDT.getTime() / 1e3);
-    const to = Math.floor(endDT.getTime() / 1e3);
-    const rangeSlot = {
-      id: `multi-day-slot-${from}-${to}`,
-      from,
-      to,
-      isMultiDay: true,
-      timeText: `9:00 AM - 5:00 PM daily`,
-      dateRange: `${this.formatDateDisplay(state.startDate)} to ${this.formatDateDisplay(state.endDate)}`,
-      day: state.startDate
-    };
-    store2.setKey("slots", [rangeSlot]);
-    store2.setKey("selectedSlot", rangeSlot);
-  },
-  resetDateSelection() {
-    store2.setKey("startDate", null);
-    store2.setKey("endDate", null);
-    store2.setKey("selectedDate", null);
-    store2.setKey("slots", []);
-    store2.setKey("selectedSlot", null);
-  },
-  selectTimeSlot(slot) {
-    store2.setKey("selectedSlot", slot);
-  },
-  setSelectedTimeZone(zone) {
-    const state = store2.get();
-    if (zone === state.timezone) return;
-    store2.setKey("timezone", zone);
-    if (currentStepName.get() === "datetime") {
-      if (state.selectedDate) {
-        this.fetchAvailability("day", state.selectedDate);
-      } else if (!state.selectedDate && !state.startDate) {
-        this.findFirstAvailable();
-      }
-    }
-  },
-  // Calendar helpers
-  isAvailable(cell) {
-    return cell.date && cell.available;
-  },
-  isSelectedDay(cell) {
-    if (cell.blank || !cell.date) return false;
-    const iso = `${cell.date.getFullYear()}-${String(cell.date.getMonth() + 1).padStart(2, "0")}-${String(cell.date.getDate()).padStart(2, "0")}`;
-    const state = store2.get();
-    return iso === state.startDate || iso === state.endDate || iso === state.selectedDate;
-  },
-  isInSelectedRange(cell) {
-    const state = store2.get();
-    if (cell.blank || !cell.date || !state.startDate || !state.endDate) return false;
-    const t = cell.date.getTime();
-    const a = new Date(state.startDate).getTime();
-    const b = new Date(state.endDate).getTime();
-    return t >= a && t <= b;
-  },
-  formatDateDisplay(ds) {
-    if (!ds) return "";
-    const d = new Date(ds);
-    return d.toLocaleDateString(getLocale(), { month: "short", day: "numeric" });
-  },
-  // Cart operations
-  addToCart(slot) {
-    const state = store2.get();
-    const id = crypto.randomUUID();
-    let dateDisplay, timeText;
-    if (state.isMultiDay && slot.isMultiDay) {
-      const a = new Date(slot.from * 1e3), b = new Date(slot.to * 1e3);
-      dateDisplay = `${a.toLocaleDateString(getLocale(), { month: "short", day: "numeric" })} - ${b.toLocaleDateString(getLocale(), { month: "short", day: "numeric", year: "numeric" })}`;
-      timeText = slot.timeText;
-    } else {
-      const date = state.selectedDate ? new Date(state.selectedDate) : new Date(slot.from * 1e3);
-      dateDisplay = date.toLocaleDateString(getLocale(), {
-        weekday: "short",
-        year: "numeric",
-        month: "short",
-        day: "numeric"
-      });
-      timeText = slot.timeText;
-    }
-    const blocks = (state.service?.reservationBlocks || []).map((f) => ({
-      ...f,
-      value: Array.isArray(f.value) ? f.value : [f.value]
-    }));
-    const newPart = {
-      id,
-      serviceId: state.service.id,
-      serviceName: getLocalizedString(state.service.name, getLocale()),
-      date: dateDisplay,
-      from: slot.from,
-      to: slot.to,
-      timeText,
-      isMultiDay: state.isMultiDay && (!!state.endDate || slot.isMultiDay),
-      reservationMethod: state.selectedMethod || "",
-      providerId: state.selectedProvider?.id,
-      blocks
-    };
-    const newParts = [...state.parts, newPart];
-    store2.setKey("parts", newParts);
-    cartParts.set(newParts);
-    this.resetDateSelection();
-    store2.setKey("currentStep", 1);
-    if (state.service.reservationMethods?.length > 1) {
-      store2.setKey("selectedMethod", null);
-    }
-  },
-  removePart(id) {
-    const filteredParts = store2.get().parts.filter((p) => p.id !== id);
-    store2.setKey("parts", filteredParts);
-    cartParts.set(filteredParts);
-  },
-  // Phone validation helper (using shared utility)
-  validatePhoneNumber(phone) {
-    const result = validatePhoneNumber(phone);
-    return result.isValid;
-  },
-  // Phone verification
-  async updateProfilePhone() {
-    store2.setKey("phoneError", null);
-    store2.setKey("phoneSuccess", null);
-    store2.setKey("isSendingCode", true);
-    try {
-      const phoneNumber = store2.get().phoneNumber;
-      if (!this.validatePhoneNumber(phoneNumber)) {
-        store2.setKey("phoneError", "Please enter a valid phone number");
-        return false;
-      }
-      const token = await this.getGuestToken();
-      await updateProfilePhone(token, phoneNumber);
-      store2.setKey("phoneSuccess", "Verification code sent successfully!");
-      store2.setKey("codeSentAt", Date.now());
-      return true;
-    } catch (e) {
-      store2.setKey("phoneError", e.message);
-      return false;
-    } finally {
-      store2.setKey("isSendingCode", false);
-    }
-  },
-  async verifyPhoneCode() {
-    store2.setKey("verifyError", null);
-    store2.setKey("isVerifying", true);
-    try {
-      const { phoneNumber, verificationCode } = store2.get();
-      if (!verificationCode || verificationCode.length !== 4) {
-        store2.setKey("verifyError", "Please enter a 4-digit verification code");
-        return false;
-      }
-      const token = await this.getGuestToken();
-      await verifyPhoneCode(token, phoneNumber, verificationCode);
-      store2.setKey("isPhoneVerified", true);
-      store2.setKey("phoneSuccess", null);
-      store2.setKey("verificationCode", "");
-      return true;
-    } catch (e) {
-      let errorMessage = "Invalid verification code";
-      if (e.message?.includes("expired")) {
-        errorMessage = "Verification code has expired. Please request a new one.";
-      } else if (e.message?.includes("incorrect") || e.message?.includes("invalid")) {
-        errorMessage = "Incorrect verification code. Please try again.";
-      }
-      store2.setKey("verifyError", errorMessage);
-      return false;
-    } finally {
-      store2.setKey("isVerifying", false);
-    }
-  },
-  async checkout(paymentMethod = "CASH" /* Cash */, reservationBlocks3, promoCode) {
-    const state = store2.get();
-    if (state.loading || !state.parts.length) return { success: false, error: "No parts in cart" };
-    store2.setKey("loading", true);
-    try {
-      const token = await this.getGuestToken();
-      const result = await reservationApi.checkout({
-        token,
-        businessId: state.businessId,
-        blocks: reservationBlocks3 || [],
-        parts: state.parts,
-        paymentMethod,
-        market: "us",
-        promoCode
-      });
-      if (result.success) {
-        return {
-          success: true,
-          data: {
-            reservationId: result.data?.reservationId,
-            clientSecret: result.data?.clientSecret
-          }
-        };
-      } else {
-        throw new Error(result.error);
-      }
-    } catch (e) {
-      console.error("Reservation checkout error:", e);
-      return { success: false, error: e.message };
-    } finally {
-      store2.setKey("loading", false);
-    }
-  },
-  async fetchQuote(paymentMethod = "CASH" /* Cash */, promoCode) {
-    const state = store2.get();
-    console.log("fetchQuote called with promoCode:", promoCode);
-    if (!state.parts.length) {
-      store2.setKey("quote", null);
-      store2.setKey("quoteError", null);
-      return;
-    }
-    store2.setKey("fetchingQuote", true);
-    store2.setKey("quoteError", null);
-    try {
-      const token = await this.getGuestToken();
-      const marketObj = selectedMarket.get();
-      const market = marketObj?.id || "us";
-      const curr = currency.get() || "USD";
-      console.log("Calling reservationApi.getQuote with:", { market, currency: curr, promoCode });
-      const result = await reservationApi.getQuote({
-        token,
-        businessId: state.businessId,
-        market,
-        currency: curr,
-        userId: token,
-        // Use token as userId for guests
-        parts: state.parts,
-        paymentMethod,
-        promoCode
-      });
-      if (result.success && result.data) {
-        console.log("Quote received:", result.data);
-        store2.setKey("quote", result.data);
-        store2.setKey("quoteError", null);
-      } else {
-        console.error("Quote error:", result.error);
-        store2.setKey("quote", null);
-        store2.setKey("quoteError", mapQuoteError2(result.code, result.error));
-      }
-    } catch (e) {
-      console.error("Fetch quote error:", e);
-      store2.setKey("quote", null);
-      store2.setKey("quoteError", e.message || "Failed to get quote");
-    } finally {
-      store2.setKey("fetchingQuote", false);
-    }
-  },
-  // Helpers
-  getLabel(block, locale = getLocale()) {
-    if (!block) return "";
-    if (block.properties?.label) {
-      if (typeof block.properties.label === "object") {
-        return block.properties.label[locale] || block.properties.label.en || Object.values(block.properties.label)[0] || "";
-      }
-      if (typeof block.properties.label === "string") {
-        return block.properties.label;
-      }
-    }
-    return block.key || "";
-  },
-  getServicePrice() {
-    const state = store2.get();
-    if (state.service?.prices && Array.isArray(state.service.prices)) {
-      return getMarketPrice(state.service.prices, "us");
-    }
-    return "";
-  },
-  // NEW: Get reservation total as Payment structure
-  getReservationPayment() {
-    const state = store2.get();
-    const subtotalMinor = state.parts.reduce((sum, part) => {
-      const servicePrices = state.service?.prices || [];
-      const amountMinor = servicePrices.length > 0 ? getPriceAmount(servicePrices, "US") : 0;
-      return sum + amountMinor;
-    }, 0);
-    const currencyCode = currency.get();
-    return createPaymentForCheckout(
-      subtotalMinor,
-      "US",
-      currencyCode,
-      "CASH" /* Cash */
-    );
-  }
-};
-function initReservationStore() {
-  actions2.updateCalendarGrid();
-  businessActions.init();
-  const savedParts = cartParts.get();
-  if (savedParts && savedParts.length > 0) {
-    store2.setKey("parts", savedParts);
-  }
-  store2.listen((state) => {
-    if (state.isMultiDay && state.startDate && state.endDate && currentStepName.get() === "datetime" && (!state.slots.length || !state.slots[0].isMultiDay)) {
-      actions2.createMultiDaySlot();
-    }
-    if (JSON.stringify(state.parts) !== JSON.stringify(cartParts.get())) {
-      cartParts.set(state.parts);
-    }
-  });
-  cartParts.listen((parts) => {
-    const currentParts = store2.get().parts;
-    if (JSON.stringify(parts) !== JSON.stringify(currentParts)) {
-      store2.setKey("parts", [...parts]);
-    }
-  });
-}
-function mapQuoteError2(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 get quote.";
-  }
-}
-var totalCartItems = nanostores.computed([cartItems, cartParts], (eshop, reservation) => {
-  const eshopCount = eshop?.reduce((sum, item) => sum + item.quantity, 0) || 0;
-  const reservationCount = reservation?.length || 0;
-  return eshopCount + reservationCount;
-});
-var hasEshopItems = nanostores.computed(cartItems, (items) => items?.length > 0);
-var hasReservationItems = nanostores.computed(cartParts, (items) => items?.length > 0);
-var isCartEmpty = nanostores.computed([cartItems, cartParts], (eshop, reservation) => {
-  return (!eshop || eshop.length === 0) && (!reservation || reservation.length === 0);
-});
-var showEshopSection = nanostores.computed([hasEshopItems, isCartEmpty], (hasEshop, isEmpty) => hasEshop || isEmpty);
-var showReservationSection = nanostores.computed([hasReservationItems, isCartEmpty], (hasReservation, isEmpty) => hasReservation || isEmpty);
-var showBothSections = nanostores.computed([hasEshopItems, hasReservationItems], (hasEshop, hasReservation) => hasEshop && hasReservation);
-
-// src/stores/index.ts
-function initArky(config) {
-  if (!config.apiUrl) {
-    throw new Error("apiUrl is required");
-  }
-  if (!config.businessId) {
-    throw new Error("businessId is required");
-  }
-  setGlobalConfig(config);
-  return config;
-}
-
-exports.allowedPaymentMethods = allowedPaymentMethods;
-exports.businessActions = businessActions;
-exports.businessStore = businessStore;
-exports.canProceed = canProceed;
-exports.cartItemCount = cartItemCount;
-exports.cartItems = cartItems;
-exports.cartParts = cartParts;
-exports.cartTotal = cartTotal;
-exports.currency = currency;
-exports.currencySymbol = currencySymbol;
-exports.currentStepName = currentStepName;
-exports.eshopActions = actions;
-exports.eshopStore = store;
-exports.getShippingMethodsForCountry = getShippingMethodsForCountry;
-exports.getZoneByCountry = getZoneByCountry;
-exports.hasEshopItems = hasEshopItems;
-exports.hasReservationItems = hasReservationItems;
-exports.initArky = initArky;
-exports.initEshopStore = initEshopStore;
-exports.initReservationStore = initReservationStore;
-exports.isCartEmpty = isCartEmpty;
-exports.markets = markets;
-exports.orderBlocks = orderBlocks;
-exports.paymentConfig = paymentConfig;
-exports.paymentMethods = paymentMethods;
-exports.promoCodeAtom = promoCodeAtom;
-exports.quoteAtom = quoteAtom;
-exports.reservationActions = actions2;
-exports.reservationBlocks = reservationBlocks;
-exports.reservationStore = store2;
-exports.selectedMarket = selectedMarket;
-exports.showBothSections = showBothSections;
-exports.showEshopSection = showEshopSection;
-exports.showReservationSection = showReservationSection;
-exports.totalCartItems = totalCartItems;
-exports.zones = zones;
-//# sourceMappingURL=stores.cjs.map
-//# sourceMappingURL=stores.cjs.map