@shoppexio/storefront 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1697 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CartError: () => CartError,
+  NetworkError: () => NetworkError,
+  NotInitializedError: () => NotInitializedError,
+  ShoppexError: () => ShoppexError,
+  ValidationError: () => ValidationError,
+  default: () => src_default,
+  fetchPublishedThemeSettings: () => fetchPublishedThemeSettings,
+  getMenuBySlot: () => getMenuBySlot,
+  getMenuByTitle: () => getMenuByTitle,
+  getMenuSlotTitles: () => getMenuSlotTitles,
+  mergeSettings: () => mergeSettings,
+  resolveDefaults: () => resolveDefaults,
+  shoppex: () => shoppex,
+  trackPageView: () => trackPageView
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../sdk/src/core/errors.ts
+var ShoppexError = class _ShoppexError extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.name = "ShoppexError";
+    this.code = code;
+    this.statusCode = statusCode;
+    Object.setPrototypeOf(this, _ShoppexError.prototype);
+  }
+};
+var NotInitializedError = class _NotInitializedError extends ShoppexError {
+  constructor() {
+    super(
+      "SDK not initialized. Call shoppex.init() first.",
+      "NOT_INITIALIZED"
+    );
+    this.name = "NotInitializedError";
+    Object.setPrototypeOf(this, _NotInitializedError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends ShoppexError {
+  constructor(message, statusCode) {
+    super(message, "NETWORK_ERROR", statusCode);
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends ShoppexError {
+  constructor(message, invalidFields) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+    this.invalidFields = invalidFields;
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var CartError = class _CartError extends ShoppexError {
+  constructor(message) {
+    super(message, "BASKET_ERROR");
+    this.name = "CartError";
+    Object.setPrototypeOf(this, _CartError.prototype);
+  }
+};
+
+// ../sdk/src/core/config.ts
+var DEFAULT_API_BASE_URL = "https://api.shoppex.io";
+var currentConfig = null;
+var cachedShopId = null;
+var DEFAULT_CHECKOUT_BASE_URL = "https://checkout.shoppex.io";
+function initConfig(storeSlug, options) {
+  cachedShopId = null;
+  currentConfig = {
+    storeSlug,
+    locale: options?.locale,
+    currency: options?.currency,
+    apiBaseUrl: options?.apiBaseUrl ?? DEFAULT_API_BASE_URL,
+    checkoutBaseUrl: options?.checkoutBaseUrl ?? DEFAULT_CHECKOUT_BASE_URL
+  };
+  return currentConfig;
+}
+function getConfig() {
+  if (!currentConfig) {
+    throw new NotInitializedError();
+  }
+  return currentConfig;
+}
+function isInitialized() {
+  return currentConfig !== null;
+}
+function setShopId(shopId) {
+  cachedShopId = shopId;
+}
+function getShopId() {
+  return cachedShopId;
+}
+
+// ../sdk/src/core/cache.ts
+var cache = /* @__PURE__ */ new Map();
+var pending = /* @__PURE__ */ new Map();
+var stats = {
+  hits: 0,
+  misses: 0
+};
+function isExpired(entry) {
+  return Date.now() > entry.expiresAt;
+}
+function getCacheStats() {
+  return {
+    hits: stats.hits,
+    misses: stats.misses,
+    pendingRequests: pending.size,
+    entries: cache.size
+  };
+}
+function clearCache() {
+  cache.clear();
+  pending.clear();
+}
+function invalidateCache(prefixOrKey) {
+  for (const key of cache.keys()) {
+    if (key === prefixOrKey || key.startsWith(prefixOrKey)) {
+      cache.delete(key);
+    }
+  }
+}
+function setCacheEntry(key, data, ttl) {
+  const now = Date.now();
+  cache.set(key, {
+    data,
+    ttl,
+    updatedAt: now,
+    expiresAt: now + ttl
+  });
+}
+function getCacheEntry(key) {
+  const entry = cache.get(key);
+  if (!entry) return null;
+  return entry;
+}
+async function getOrFetch(key, fetcher, options, shouldCache = () => true) {
+  const entry = getCacheEntry(key);
+  if (entry && !isExpired(entry)) {
+    stats.hits += 1;
+    return entry.data;
+  }
+  if (entry && options.staleWhileRevalidate) {
+    stats.hits += 1;
+    if (!pending.has(key)) {
+      const refreshPromise = (async () => {
+        try {
+          const data = await fetcher();
+          if (shouldCache(data)) {
+            setCacheEntry(key, data, options.ttl);
+          }
+          return data;
+        } finally {
+          pending.delete(key);
+        }
+      })();
+      pending.set(key, refreshPromise);
+    }
+    return entry.data;
+  }
+  if (pending.has(key)) {
+    return pending.get(key);
+  }
+  stats.misses += 1;
+  const promise = (async () => {
+    try {
+      const data = await fetcher();
+      if (shouldCache(data)) {
+        setCacheEntry(key, data, options.ttl);
+      }
+      return data;
+    } finally {
+      pending.delete(key);
+    }
+  })();
+  pending.set(key, promise);
+  return promise;
+}
+
+// ../sdk/src/core/client.ts
+var DEFAULT_TIMEOUT = 1e4;
+var MAX_RETRIES = 2;
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function request(endpoint, options = {}) {
+  const config = options.baseUrl ? null : getConfig();
+  const {
+    method = "GET",
+    body,
+    timeout = DEFAULT_TIMEOUT,
+    retries,
+    baseUrl,
+    cache: cache2
+  } = options;
+  const retryCount = retries ?? (method === "GET" ? MAX_RETRIES : 0);
+  const apiBaseUrl = baseUrl ?? config?.apiBaseUrl ?? "";
+  const url = `${apiBaseUrl}${endpoint}`;
+  const headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+  let lastError = null;
+  const executeRequest = async () => {
+    for (let attempt = 0; attempt <= retryCount; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const payload = await parseResponsePayload(response);
+        if (!response.ok) {
+          const fallbackHttpMessage = response.statusText ? `HTTP ${response.status}: ${response.statusText}` : `HTTP ${response.status}`;
+          const message = (payload.data && typeof payload.data === "object" && "error" in payload.data && typeof payload.data.error === "string" ? payload.data.error : null) ?? (payload.data && typeof payload.data === "object" && "message" in payload.data && typeof payload.data.message === "string" ? payload.data.message : null) ?? payload.rawText ?? fallbackHttpMessage;
+          throw new NetworkError(message, response.status);
+        }
+        if (response.status === 204 && payload.data === null) {
+          return {
+            success: true
+          };
+        }
+        if (!payload.data || typeof payload.data !== "object" || !("status" in payload.data)) {
+          throw new NetworkError("Invalid API response", response.status);
+        }
+        const data = payload.data;
+        return mapApiResponse(data);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (error instanceof DOMException && error.name === "AbortError") {
+          lastError = new NetworkError("Request timeout", 408);
+        }
+        if (attempt < retryCount) {
+          await sleep(Math.pow(2, attempt) * 500);
+          continue;
+        }
+      }
+    }
+    return {
+      success: false,
+      message: lastError?.message ?? "Unknown error"
+    };
+  };
+  if (method === "GET" && cache2 && cache2.ttl > 0) {
+    const cacheKey = cache2.key ?? `GET:${url}`;
+    return getOrFetch(
+      cacheKey,
+      executeRequest,
+      { ttl: cache2.ttl, staleWhileRevalidate: cache2.staleWhileRevalidate },
+      (value) => value.success
+    );
+  }
+  return executeRequest();
+}
+async function parseResponsePayload(response) {
+  const responseWithOptionalMethods = response;
+  if (typeof responseWithOptionalMethods.text !== "function") {
+    if (typeof responseWithOptionalMethods.json === "function") {
+      try {
+        return {
+          data: await responseWithOptionalMethods.json(),
+          rawText: null
+        };
+      } catch {
+        return { data: null, rawText: null };
+      }
+    }
+    return { data: null, rawText: null };
+  }
+  try {
+    const rawText = await responseWithOptionalMethods.text();
+    if (!rawText) {
+      return { data: null, rawText: null };
+    }
+    try {
+      return {
+        data: JSON.parse(rawText),
+        rawText: null
+      };
+    } catch {
+      const normalizedText = rawText.trim();
+      return {
+        data: null,
+        rawText: normalizedText.length > 0 ? normalizedText : null
+      };
+    }
+  } catch {
+    return { data: null, rawText: null };
+  }
+}
+function mapApiResponse(apiResponse) {
+  if (apiResponse.status >= 200 && apiResponse.status < 300) {
+    return {
+      success: true,
+      data: apiResponse.data
+    };
+  }
+  return {
+    success: false,
+    message: apiResponse.error ?? `Request failed with status ${apiResponse.status}`
+  };
+}
+async function get(endpoint, options) {
+  return request(endpoint, { ...options, method: "GET" });
+}
+async function post(endpoint, body, options) {
+  return request(endpoint, { ...options, method: "POST", body });
+}
+
+// ../sdk/src/core/endpoint.ts
+var PARAM_PATTERN = /:([A-Za-z0-9_]+)/g;
+function buildEndpoint(template, params) {
+  return template.replace(PARAM_PATTERN, (_, key) => {
+    const rawValue = params[key];
+    if (rawValue === null || rawValue === void 0) {
+      throw new Error(`Missing endpoint param: ${key}`);
+    }
+    const value = String(rawValue).trim();
+    if (!value) {
+      throw new Error(`Endpoint param "${key}" must not be empty`);
+    }
+    return encodeURIComponent(value);
+  });
+}
+
+// ../sdk/src/modules/store.ts
+var STORE_CACHE_TTL = 5 * 60 * 1e3;
+async function getStore() {
+  const config = getConfig();
+  const response = await get(
+    buildEndpoint("/v1/storefront/shops/name/:storeSlug", {
+      storeSlug: config.storeSlug
+    }),
+    {
+      cache: {
+        key: `store:${config.storeSlug}`,
+        ttl: STORE_CACHE_TTL,
+        staleWhileRevalidate: true
+      }
+    }
+  );
+  if (response.success && response.data) {
+    if (response.data.shop?.id) {
+      setShopId(response.data.shop.id);
+    }
+    return {
+      success: true,
+      data: response.data.shop
+    };
+  }
+  return {
+    success: false,
+    message: response.message
+  };
+}
+async function resolveStoreByDomain(domain, apiBaseUrl) {
+  const resolvedDomain = domain ?? (typeof window !== "undefined" ? window.location.hostname : "");
+  if (!resolvedDomain) {
+    return {
+      success: false,
+      message: "Domain is required to resolve store"
+    };
+  }
+  const cleanDomain = resolvedDomain.replace(/^https?:\/\//, "").split("/")[0].trim();
+  const baseUrl = apiBaseUrl ?? (isInitialized() ? getConfig().apiBaseUrl : DEFAULT_API_BASE_URL);
+  const response = await get(
+    buildEndpoint("/v1/storefront/shops/domain/:domain", {
+      domain: cleanDomain
+    }),
+    {
+      baseUrl,
+      cache: {
+        key: `store:domain:${cleanDomain}`,
+        ttl: STORE_CACHE_TTL,
+        staleWhileRevalidate: true
+      }
+    }
+  );
+  if (response.success && response.data?.shop) {
+    return {
+      success: true,
+      data: response.data.shop
+    };
+  }
+  return {
+    success: false,
+    message: response.message ?? "Failed to resolve store"
+  };
+}
+async function getStorefront() {
+  const config = getConfig();
+  const response = await get(
+    buildEndpoint("/v1/storefront/shops/name/:storeSlug", {
+      storeSlug: config.storeSlug
+    }),
+    {
+      cache: {
+        key: `storefront:${config.storeSlug}`,
+        ttl: STORE_CACHE_TTL,
+        staleWhileRevalidate: true
+      }
+    }
+  );
+  if (response.success && response.data) {
+    if (response.data.shop?.id) {
+      setShopId(response.data.shop.id);
+    }
+    return {
+      success: true,
+      data: {
+        shop: response.data.shop,
+        products: response.data.products ?? [],
+        groups: response.data.groups ?? [],
+        items: response.data.items ?? [],
+        categories: response.data.categories ?? [],
+        addons: response.data.addons ?? { items: [] }
+      }
+    };
+  }
+  return {
+    success: false,
+    message: response.message
+  };
+}
+async function getStoreLogoUrl() {
+  const response = await getStore();
+  if (response.success && response.data?.logo) {
+    return response.data.logo;
+  }
+  return null;
+}
+async function getStoreBannerUrl() {
+  const response = await getStore();
+  if (response.success && response.data?.banner) {
+    return response.data.banner;
+  }
+  return null;
+}
+
+// ../sdk/src/modules/products.ts
+var PRODUCTS_CACHE_TTL = 2 * 60 * 1e3;
+async function getProducts() {
+  const config = getConfig();
+  const response = await get(
+    buildEndpoint("/v1/storefront/products/public/:storeSlug", {
+      storeSlug: config.storeSlug
+    }),
+    {
+      cache: {
+        key: `products:${config.storeSlug}`,
+        ttl: PRODUCTS_CACHE_TTL,
+        staleWhileRevalidate: true
+      }
+    }
+  );
+  if (response.success && response.data) {
+    return {
+      success: true,
+      data: response.data.products
+    };
+  }
+  return {
+    success: false,
+    message: response.message,
+    data: []
+  };
+}
+async function getProduct(idOrSlug) {
+  const shopId = getShopId();
+  const queryParams = shopId ? `?slug_shop_id=${encodeURIComponent(shopId)}` : "";
+  const response = await get(
+    `${buildEndpoint("/v1/storefront/products/unique/:idOrSlug", { idOrSlug })}${queryParams}`,
+    {
+      cache: {
+        key: `product:${idOrSlug}:${shopId ?? "no-shop"}`,
+        ttl: PRODUCTS_CACHE_TTL,
+        staleWhileRevalidate: true
+      }
+    }
+  );
+  if (response.success && response.data?.product) {
+    return {
+      success: true,
+      data: response.data.product
+    };
+  }
+  return {
+    success: false,
+    message: response.message
+  };
+}
+async function getCategories() {
+  const products = await getProducts();
+  if (!products.success || !products.data) {
+    return {
+      success: false,
+      message: products.message
+    };
+  }
+  const categories = /* @__PURE__ */ new Set();
+  for (const product of products.data) {
+    if (product.categories) {
+      for (const category of product.categories) {
+        if (typeof category === "string") {
+          categories.add(category);
+        } else if (category && typeof category === "object" && "uniqid" in category) {
+          categories.add(category.uniqid);
+        }
+      }
+    }
+  }
+  return {
+    success: true,
+    data: Array.from(categories)
+  };
+}
+
+// ../sdk/src/utils/storage.ts
+var STORAGE_PREFIX = "shoppex_";
+function getKey(key) {
+  return `${STORAGE_PREFIX}${key}`;
+}
+function getItem(key) {
+  try {
+    const item = localStorage.getItem(getKey(key));
+    if (!item) return null;
+    return JSON.parse(item);
+  } catch {
+    return null;
+  }
+}
+function setItem(key, value) {
+  try {
+    localStorage.setItem(getKey(key), JSON.stringify(value));
+  } catch {
+    console.warn("[shoppex] Failed to save to localStorage");
+  }
+}
+function removeItem(key) {
+  try {
+    localStorage.removeItem(getKey(key));
+  } catch {
+  }
+}
+
+// ../sdk/src/modules/cart.ts
+var STORAGE_KEYS = {
+  cart: "cart",
+  cartBackup: "cart_backup",
+  meta: "cart_meta",
+  metaBackup: "cart_backup_meta"
+};
+function getStorageKey(type) {
+  return `${STORAGE_KEYS[type]}_${getConfig().storeSlug}`;
+}
+function hashString(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i += 1) {
+    hash ^= value.charCodeAt(i);
+    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  }
+  return (hash >>> 0).toString(16);
+}
+function computeChecksum(cart) {
+  return hashString(JSON.stringify(cart));
+}
+function normalizeQuantity(value) {
+  if (!Number.isFinite(value)) {
+    throw new CartError("quantity must be a finite number");
+  }
+  return Math.floor(value);
+}
+function normalizeCartItems(value) {
+  if (!Array.isArray(value)) return [];
+  const normalized = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object") continue;
+    const record = entry;
+    const productId = typeof record.product_id === "string" ? record.product_id.trim() : "";
+    const variantId = typeof record.variant_id === "string" ? record.variant_id.trim() : "";
+    const quantity = Number(record.quantity);
+    if (!productId || !variantId || !Number.isFinite(quantity) || quantity < 1) {
+      continue;
+    }
+    const item = {
+      product_id: productId,
+      variant_id: variantId,
+      quantity: Math.floor(quantity)
+    };
+    if (typeof record.price_variant_id === "string") {
+      item.price_variant_id = record.price_variant_id;
+    }
+    if (record.price_data && typeof record.price_data === "object") {
+      const priceData = record.price_data;
+      if (typeof priceData.unit_price === "number" && Number.isFinite(priceData.unit_price)) {
+        item.price_data = { unit_price: priceData.unit_price };
+      }
+    }
+    if (Array.isArray(record.addons)) {
+      item.addons = record.addons;
+    }
+    if (record.custom_fields && typeof record.custom_fields === "object" && !Array.isArray(record.custom_fields)) {
+      item.custom_fields = record.custom_fields;
+    }
+    normalized.push(item);
+  }
+  return normalized;
+}
+function getCartMetadata() {
+  return getItem(getStorageKey("meta"));
+}
+function writeCart(cart) {
+  setItem(getStorageKey("cart"), cart);
+  const now = Date.now();
+  const previous = getCartMetadata();
+  const nextMeta = {
+    created_at: previous?.created_at ?? now,
+    last_modified: now,
+    version: (previous?.version ?? 0) + 1,
+    checksum: computeChecksum(cart)
+  };
+  setItem(getStorageKey("meta"), nextMeta);
+}
+function setCartWithMetadata(cart, metadata) {
+  setItem(getStorageKey("cart"), cart);
+  const now = Date.now();
+  const base = metadata ?? getCartMetadata();
+  const nextMeta = {
+    created_at: base?.created_at ?? now,
+    last_modified: now,
+    version: base?.version ?? 1,
+    checksum: computeChecksum(cart)
+  };
+  setItem(getStorageKey("meta"), nextMeta);
+}
+function getCart() {
+  const raw = getItem(getStorageKey("cart"));
+  return normalizeCartItems(raw);
+}
+function getCartItemCount() {
+  const cart = getCart();
+  return cart.reduce((sum, item) => sum + item.quantity, 0);
+}
+function addToCart(productId, variantId, quantity = 1, options) {
+  if (!productId || !variantId) {
+    throw new CartError("product_id and variant_id are required");
+  }
+  const normalizedQuantity = normalizeQuantity(quantity);
+  if (normalizedQuantity < 1) {
+    throw new CartError("quantity must be at least 1");
+  }
+  const cart = getCart();
+  const existingIndex = cart.findIndex(
+    (item) => item.product_id === productId && item.variant_id === variantId
+  );
+  if (existingIndex >= 0) {
+    cart[existingIndex].quantity += normalizedQuantity;
+    if (options?.addons) {
+      cart[existingIndex].addons = options.addons;
+    }
+    if (options?.custom_fields) {
+      cart[existingIndex].custom_fields = options.custom_fields;
+    }
+    if (options?.price_variant_id) {
+      cart[existingIndex].price_variant_id = options.price_variant_id;
+    }
+    if (options?.price_data) {
+      cart[existingIndex].price_data = options.price_data;
+    }
+  } else {
+    cart.push({
+      product_id: productId,
+      variant_id: variantId,
+      quantity: normalizedQuantity,
+      addons: options?.addons,
+      custom_fields: options?.custom_fields,
+      price_variant_id: options?.price_variant_id,
+      price_data: options?.price_data
+    });
+  }
+  writeCart(cart);
+}
+function updateCartItem(productId, variantId, updates) {
+  const cart = getCart();
+  const index = cart.findIndex(
+    (item) => item.product_id === productId && item.variant_id === variantId
+  );
+  if (index < 0) {
+    throw new CartError("Item not found in cart");
+  }
+  if (updates.quantity !== void 0) {
+    const normalizedQuantity = normalizeQuantity(updates.quantity);
+    if (normalizedQuantity < 1) {
+      cart.splice(index, 1);
+      writeCart(cart);
+      return;
+    }
+    cart[index].quantity = normalizedQuantity;
+  }
+  if (updates.addons !== void 0) {
+    cart[index].addons = updates.addons;
+  }
+  if (updates.custom_fields !== void 0) {
+    cart[index].custom_fields = updates.custom_fields;
+  }
+  if (updates.price_variant_id !== void 0) {
+    cart[index].price_variant_id = updates.price_variant_id;
+  }
+  if (updates.price_data !== void 0) {
+    cart[index].price_data = updates.price_data;
+  }
+  writeCart(cart);
+}
+function removeFromCart(productId, variantId) {
+  const cart = getCart();
+  const filtered = cart.filter(
+    (item) => !(item.product_id === productId && item.variant_id === variantId)
+  );
+  writeCart(filtered);
+}
+function clearCart() {
+  removeItem(getStorageKey("cart"));
+  removeItem(getStorageKey("meta"));
+}
+function createCartBackup() {
+  const cart = getCart();
+  setItem(getStorageKey("cartBackup"), cart);
+  const metadata = getCartMetadata();
+  if (metadata) {
+    setItem(getStorageKey("metaBackup"), metadata);
+  } else {
+    const now = Date.now();
+    setItem(getStorageKey("metaBackup"), {
+      created_at: now,
+      last_modified: now,
+      version: 1,
+      checksum: computeChecksum(cart)
+    });
+  }
+}
+function restoreCartFromBackup() {
+  const backupRaw = getItem(getStorageKey("cartBackup"));
+  const backup = normalizeCartItems(backupRaw);
+  const backupMeta = getItem(getStorageKey("metaBackup"));
+  if (backup && backup.length > 0) {
+    setCartWithMetadata(backup, backupMeta);
+    return true;
+  }
+  return false;
+}
+function mergeBaskets(items) {
+  const cart = getCart();
+  for (const incoming of items) {
+    const productId = typeof incoming.product_id === "string" ? incoming.product_id.trim() : "";
+    const variantId = typeof incoming.variant_id === "string" ? incoming.variant_id.trim() : "";
+    if (!productId || !variantId) {
+      continue;
+    }
+    let normalizedQuantity;
+    try {
+      normalizedQuantity = normalizeQuantity(incoming.quantity);
+    } catch {
+      continue;
+    }
+    if (normalizedQuantity < 1) {
+      continue;
+    }
+    const index = cart.findIndex(
+      (item) => item.product_id === productId && item.variant_id === variantId
+    );
+    if (index >= 0) {
+      cart[index].quantity = Math.max(cart[index].quantity, normalizedQuantity);
+    } else {
+      cart.push({
+        ...incoming,
+        product_id: productId,
+        variant_id: variantId,
+        quantity: normalizedQuantity
+      });
+    }
+  }
+  writeCart(cart);
+  return cart;
+}
+function moveBasketItem(fromProductId, fromVariantId, toProductId, toVariantId) {
+  const cart = getCart();
+  const fromIndex = cart.findIndex(
+    (item) => item.product_id === fromProductId && item.variant_id === fromVariantId
+  );
+  if (fromIndex < 0) {
+    throw new CartError("Item not found in cart");
+  }
+  const [fromItem] = cart.splice(fromIndex, 1);
+  const toIndex = cart.findIndex(
+    (item) => item.product_id === toProductId && item.variant_id === toVariantId
+  );
+  if (toIndex >= 0) {
+    cart[toIndex].quantity += fromItem.quantity;
+  } else {
+    cart.push({
+      ...fromItem,
+      product_id: toProductId,
+      variant_id: toVariantId
+    });
+  }
+  writeCart(cart);
+}
+function validateCartIntegrity() {
+  const cart = getCart();
+  const metadata = getCartMetadata();
+  const checksum = computeChecksum(cart);
+  if (!metadata) {
+    setCartWithMetadata(cart, null);
+    return true;
+  }
+  return metadata.checksum === checksum;
+}
+function getCartStats() {
+  const cart = getCart();
+  const integrityValid = validateCartIntegrity();
+  const metadata = getCartMetadata();
+  const backup = getItem(getStorageKey("cartBackup")) ?? [];
+  const hasCompletePriceSnapshots = cart.length > 0 && cart.every((item) => typeof item.price_data?.unit_price === "number");
+  const totalPrice = cart.reduce((sum, item) => {
+    const unitPrice = item.price_data?.unit_price ?? 0;
+    return sum + unitPrice * item.quantity;
+  }, 0);
+  return {
+    item_count: cart.length,
+    total_quantity: cart.reduce((sum, item) => sum + item.quantity, 0),
+    last_modified: metadata?.last_modified ?? 0,
+    version: metadata?.version ?? 0,
+    has_backup: backup.length > 0,
+    integrity_valid: integrityValid,
+    total_price: totalPrice,
+    total_price_is_estimate: cart.length > 0 && !hasCompletePriceSnapshots
+  };
+}
+
+// ../sdk/src/modules/checkout.ts
+var CHECKOUT_PREFILL_EMAIL_HASH_KEY = "shoppex_prefill_email";
+function normalizeCoupon(coupon) {
+  const normalized = coupon?.trim();
+  return normalized ? normalized : null;
+}
+function normalizeEmail(email) {
+  const normalized = email?.trim();
+  return normalized ? normalized : null;
+}
+function normalizeCheckoutFailureMessage(rawMessage) {
+  const message = rawMessage?.trim() ?? "";
+  if (!message) {
+    return "Checkout failed. Please try again.";
+  }
+  if (isStaleCartProductError(message)) {
+    return "Your cart is outdated. Please add the products again.";
+  }
+  const httpMatch = message.match(/^HTTP\s+(\d{3})(?::\s*(.*))?$/i);
+  if (httpMatch) {
+    const status = Number(httpMatch[1]);
+    const detail = httpMatch[2]?.trim();
+    if (detail && detail.length > 0) {
+      return `Checkout failed: ${detail}`;
+    }
+    if (status >= 500) {
+      return "Checkout is temporarily unavailable. Please try again.";
+    }
+    if (status === 400) {
+      return "Checkout failed. Please check your details and try again.";
+    }
+    if (status === 401 || status === 403) {
+      return "Checkout is currently unavailable for this request.";
+    }
+    return "Checkout failed. Please try again.";
+  }
+  if (/^internal server error$/i.test(message)) {
+    return "Checkout is temporarily unavailable. Please try again.";
+  }
+  return message;
+}
+function isStaleCartProductError(rawMessage) {
+  const message = rawMessage?.trim().toLowerCase() ?? "";
+  if (!message) {
+    return false;
+  }
+  return message.includes("product not found") || message.includes("product not available") || message.includes("products are no longer available") || message.includes("outdated product");
+}
+function validateCheckoutUrl(checkoutUrl, checkoutBaseUrl, expectedInvoiceId) {
+  const expectedBaseUrl = checkoutBaseUrl?.trim();
+  if (!expectedBaseUrl) {
+    return null;
+  }
+  try {
+    const parsedCheckoutUrl = new URL(checkoutUrl);
+    const parsedExpectedBaseUrl = new URL(expectedBaseUrl);
+    if (parsedCheckoutUrl.origin !== parsedExpectedBaseUrl.origin) {
+      return null;
+    }
+    const normalizedPath = parsedCheckoutUrl.pathname.replace(/\/+$/, "");
+    const normalizedBasePath = parsedExpectedBaseUrl.pathname.replace(/\/+$/, "");
+    const expectedInvoicePath = `${normalizedBasePath}/invoice/`.replace(/\/{2,}/g, "/");
+    if (!normalizedPath.startsWith(expectedInvoicePath)) {
+      return null;
+    }
+    const invoiceIdSegment = normalizedPath.slice(expectedInvoicePath.length);
+    if (!invoiceIdSegment || invoiceIdSegment.includes("/")) {
+      return null;
+    }
+    if (expectedInvoiceId) {
+      const normalizedExpectedInvoiceId = expectedInvoiceId.trim();
+      const invoiceIdFromUrl = decodeURIComponent(invoiceIdSegment);
+      if (!normalizedExpectedInvoiceId || invoiceIdFromUrl !== normalizedExpectedInvoiceId) {
+        return null;
+      }
+    }
+    return parsedCheckoutUrl.toString();
+  } catch {
+    return null;
+  }
+}
+function buildCheckoutUrlFromInvoiceId(checkoutBaseUrl, invoiceId) {
+  const normalizedBaseUrl = checkoutBaseUrl?.trim();
+  if (!normalizedBaseUrl) {
+    return null;
+  }
+  try {
+    const baseUrl = new URL(normalizedBaseUrl);
+    const basePath = baseUrl.pathname.replace(/\/+$/, "");
+    baseUrl.pathname = `${basePath}/invoice/${encodeURIComponent(invoiceId)}`.replace(/\/{2,}/g, "/");
+    baseUrl.search = "";
+    baseUrl.hash = "";
+    return baseUrl.toString();
+  } catch {
+    return null;
+  }
+}
+function appendPrefillEmailToCheckoutUrl(checkoutUrl, email) {
+  const normalizedEmail = normalizeEmail(email);
+  if (!normalizedEmail) {
+    return checkoutUrl;
+  }
+  try {
+    const parsedCheckoutUrl = new URL(checkoutUrl);
+    const hashParams = new URLSearchParams(parsedCheckoutUrl.hash.startsWith("#") ? parsedCheckoutUrl.hash.slice(1) : parsedCheckoutUrl.hash);
+    hashParams.set(CHECKOUT_PREFILL_EMAIL_HASH_KEY, normalizedEmail);
+    parsedCheckoutUrl.hash = hashParams.toString();
+    return parsedCheckoutUrl.toString();
+  } catch {
+    return checkoutUrl;
+  }
+}
+function normalizeCheckoutResponse(response, checkoutBaseUrl) {
+  const nestedInvoice = response?.invoice;
+  const invoiceId = response?.invoiceId?.trim() || response?.invoice_id?.trim() || response?.uniqid?.trim() || nestedInvoice?.invoiceId?.trim() || nestedInvoice?.invoice_id?.trim() || nestedInvoice?.uniqid?.trim();
+  let checkoutUrl = response?.checkoutUrl?.trim() || response?.checkout_url?.trim() || response?.url_branded?.trim() || response?.url?.trim() || nestedInvoice?.checkoutUrl?.trim() || nestedInvoice?.checkout_url?.trim() || nestedInvoice?.url_branded?.trim() || nestedInvoice?.url?.trim();
+  if (!checkoutUrl && invoiceId && nestedInvoice) {
+    checkoutUrl = buildCheckoutUrlFromInvoiceId(checkoutBaseUrl, invoiceId) ?? void 0;
+  }
+  if (!invoiceId || !checkoutUrl) {
+    return null;
+  }
+  return { invoiceId, checkoutUrl };
+}
+function resolveCheckoutOptions(couponOrOptions, options) {
+  if (typeof couponOrOptions === "string") {
+    return {
+      ...options,
+      coupon: couponOrOptions
+    };
+  }
+  return couponOrOptions ?? options ?? {};
+}
+function mapCartItemsForApi(items) {
+  const normalizeVariantIdForApi = (value) => {
+    const normalized = value?.trim();
+    if (!normalized) return null;
+    if (normalized.toLowerCase() === "default") return null;
+    return normalized;
+  };
+  return items.map((item) => ({
+    product_id: item.product_id,
+    variant_id: normalizeVariantIdForApi(item.variant_id),
+    quantity: item.quantity,
+    addons: item.addons?.map((a) => ({ id: a.id, quantity: a.quantity ?? 1 })),
+    custom_fields: item.custom_fields,
+    price_variant_id: item.price_variant_id || null
+  }));
+}
+async function checkout(couponOrOptions, options) {
+  const resolvedOptions = resolveCheckoutOptions(couponOrOptions, options);
+  const { autoRedirect = true, email, coupon, affiliateCode } = resolvedOptions;
+  const normalizedCoupon = normalizeCoupon(coupon);
+  const normalizedEmail = normalizeEmail(email);
+  const normalizedAffiliateCode = typeof affiliateCode === "string" && affiliateCode.trim().length > 0 ? affiliateCode.trim() : null;
+  const cart = getCart();
+  if (cart.length === 0) {
+    return {
+      success: false,
+      message: "Cart is empty"
+    };
+  }
+  createCartBackup();
+  const config = getConfig();
+  let response = await post("/v1/storefront/invoices/from-cart", {
+    shop_slug: config.storeSlug,
+    cart: mapCartItemsForApi(cart),
+    email: normalizedEmail,
+    coupon: normalizedCoupon,
+    affiliate_code: normalizedAffiliateCode
+  }, { retries: 0 });
+  if (!response.success || !response.data) {
+    if (isStaleCartProductError(response.message)) {
+      clearCart();
+    }
+    return {
+      success: false,
+      message: normalizeCheckoutFailureMessage(response.message)
+    };
+  }
+  const checkoutData = normalizeCheckoutResponse(response.data, config.checkoutBaseUrl);
+  if (!checkoutData) {
+    return {
+      success: false,
+      message: "Failed to create invoice"
+    };
+  }
+  const { invoiceId } = checkoutData;
+  const safeCheckoutUrl = validateCheckoutUrl(
+    checkoutData.checkoutUrl,
+    config.checkoutBaseUrl,
+    invoiceId
+  );
+  if (!safeCheckoutUrl) {
+    return {
+      success: false,
+      message: "Failed to create invoice"
+    };
+  }
+  const checkoutUrlWithPrefill = appendPrefillEmailToCheckoutUrl(safeCheckoutUrl, normalizedEmail);
+  if (autoRedirect) {
+    if (typeof window !== "undefined" && window?.location) {
+      window.location.href = checkoutUrlWithPrefill;
+      clearCart();
+    }
+  }
+  return {
+    success: true,
+    redirectUrl: checkoutUrlWithPrefill,
+    invoiceId
+  };
+}
+async function buildCheckoutUrl(couponOrOptions, options) {
+  const resolvedOptions = resolveCheckoutOptions(couponOrOptions, options);
+  const { email, coupon, affiliateCode } = resolvedOptions;
+  const normalizedCoupon = normalizeCoupon(coupon);
+  const normalizedEmail = normalizeEmail(email);
+  const normalizedAffiliateCode = typeof affiliateCode === "string" && affiliateCode.trim().length > 0 ? affiliateCode.trim() : null;
+  const cart = getCart();
+  if (cart.length === 0) {
+    throw new Error("Cart is empty");
+  }
+  const config = getConfig();
+  let response = await post("/v1/storefront/invoices/from-cart", {
+    shop_slug: config.storeSlug,
+    cart: mapCartItemsForApi(cart),
+    email: normalizedEmail,
+    coupon: normalizedCoupon,
+    affiliate_code: normalizedAffiliateCode
+  }, { retries: 0 });
+  if (!response.success || !response.data) {
+    if (isStaleCartProductError(response.message)) {
+      clearCart();
+    }
+    throw new Error(normalizeCheckoutFailureMessage(response.message));
+  }
+  const checkoutData = normalizeCheckoutResponse(response.data, config.checkoutBaseUrl);
+  if (!checkoutData) {
+    throw new Error("Failed to create invoice");
+  }
+  const safeCheckoutUrl = validateCheckoutUrl(
+    checkoutData.checkoutUrl,
+    config.checkoutBaseUrl,
+    checkoutData.invoiceId
+  );
+  if (!safeCheckoutUrl) {
+    throw new Error("Failed to create invoice");
+  }
+  return appendPrefillEmailToCheckoutUrl(safeCheckoutUrl, normalizedEmail);
+}
+function buildCheckoutUrlSync() {
+  throw new Error("buildCheckoutUrlSync is deprecated. Use buildCheckoutUrl (async) instead.");
+}
+
+// ../sdk/src/modules/affiliates.ts
+var STORAGE_KEY = "shoppex:affiliate_code:v1";
+var DEFAULT_TTL_DAYS = 30;
+function nowMs() {
+  return Date.now();
+}
+function ttlMs(days) {
+  return Math.max(1, days) * 24 * 60 * 60 * 1e3;
+}
+function safeRead() {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.code !== "string" || typeof parsed.expiresAt !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function safeWrite(value) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(value));
+  } catch {
+  }
+}
+function clearAffiliateCode() {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.removeItem(STORAGE_KEY);
+  } catch {
+  }
+}
+function getAffiliateCode() {
+  const stored = safeRead();
+  if (!stored) return null;
+  if (stored.expiresAt <= nowMs()) {
+    clearAffiliateCode();
+    return null;
+  }
+  const normalized = stored.code.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+async function captureAffiliateFromUrl(param = "ref") {
+  if (typeof window === "undefined") return null;
+  let code = null;
+  try {
+    const url = new URL(window.location.href);
+    const raw = url.searchParams.get(param);
+    code = raw ? raw.trim() : null;
+  } catch {
+    code = null;
+  }
+  if (!code) return null;
+  safeWrite({ code, expiresAt: nowMs() + ttlMs(DEFAULT_TTL_DAYS) });
+  if (isInitialized()) {
+    try {
+      const config = getConfig();
+      const res = await post(
+        "/v1/storefront/affiliates/attribution",
+        { shop_slug: config.storeSlug, code },
+        { retries: 0 }
+      );
+      if (!res.success || !res.data?.accepted || !res.data?.affiliate_code) {
+        clearAffiliateCode();
+        return null;
+      }
+      safeWrite({ code: res.data.affiliate_code, expiresAt: nowMs() + ttlMs(DEFAULT_TTL_DAYS) });
+      return res.data.affiliate_code;
+    } catch {
+      return code;
+    }
+  }
+  return code;
+}
+
+// ../sdk/src/modules/coupons.ts
+async function resolveShopId() {
+  const cachedShopId2 = getShopId();
+  if (cachedShopId2) {
+    return cachedShopId2;
+  }
+  const storeResult = await getStore();
+  if (!storeResult.success || !storeResult.data?.id) {
+    return null;
+  }
+  return storeResult.data.id;
+}
+async function validateCoupon(code, productId) {
+  const trimmedCode = code.trim();
+  if (!trimmedCode) {
+    return {
+      success: false,
+      message: "Coupon code is required"
+    };
+  }
+  const payload = {
+    code: trimmedCode
+  };
+  if (productId) {
+    payload.product_id = productId;
+  } else {
+    const cart = getCart();
+    if (cart.length === 0) {
+      return {
+        success: false,
+        message: "Cart is empty"
+      };
+    }
+    const shopId = await resolveShopId();
+    if (!shopId) {
+      return {
+        success: false,
+        message: "Failed to resolve store"
+      };
+    }
+    payload.cart = JSON.stringify({
+      shop_id: shopId,
+      products: cart.map((item) => ({
+        uniqid: item.product_id,
+        quantity: item.quantity
+      }))
+    });
+  }
+  const response = await post(
+    "/v1/storefront/coupons/check",
+    payload
+  );
+  return response;
+}
+
+// ../sdk/src/modules/reviews.ts
+async function getShopReviews() {
+  const config = getConfig();
+  const response = await get(
+    buildEndpoint("/v1/storefront/feedback/shop/:storeSlug", {
+      storeSlug: config.storeSlug
+    })
+  );
+  if (response.success && response.data) {
+    return {
+      success: true,
+      data: response.data.feedback
+    };
+  }
+  return {
+    success: false,
+    message: response.message,
+    data: []
+  };
+}
+
+// ../sdk/src/modules/search.ts
+async function searchProducts(query, options) {
+  if (!isInitialized()) {
+    return { success: false, message: "SDK not initialized" };
+  }
+  const trimmed = query.trim().toLowerCase();
+  if (!trimmed) {
+    return { success: true, data: [] };
+  }
+  const products = await getProducts();
+  if (!products.success || !products.data) {
+    return { success: false, message: products.message ?? "Failed to fetch products" };
+  }
+  let results = products.data.filter(
+    (p) => p.title.toLowerCase().includes(trimmed) || (p.description?.toLowerCase().includes(trimmed) ?? false)
+  );
+  if (options?.hideOutOfStock) {
+    results = results.filter((p) => p.stock === void 0 || p.stock === -1 || p.stock > 0);
+  }
+  return { success: true, data: results };
+}
+
+// ../sdk/src/modules/invoices.ts
+function normalizeInvoiceId(invoiceId) {
+  const normalized = invoiceId.trim();
+  if (!normalized) {
+    return null;
+  }
+  return normalized;
+}
+async function getInvoice(invoiceId) {
+  const normalizedInvoiceId = normalizeInvoiceId(invoiceId);
+  if (!normalizedInvoiceId) {
+    return {
+      success: false,
+      message: "Invoice ID is required"
+    };
+  }
+  const response = await get(
+    buildEndpoint("/v1/storefront/invoices/unique/:invoiceId", {
+      invoiceId: normalizedInvoiceId
+    })
+  );
+  if (!response.success) {
+    return {
+      success: false,
+      message: response.message
+    };
+  }
+  if (!response.data?.invoice) {
+    return {
+      success: false,
+      message: "Invalid invoice response"
+    };
+  }
+  return {
+    success: true,
+    data: response.data.invoice
+  };
+}
+async function getInvoiceStatus(invoiceId) {
+  const normalizedInvoiceId = normalizeInvoiceId(invoiceId);
+  if (!normalizedInvoiceId) {
+    return {
+      success: false,
+      message: "Invoice ID is required"
+    };
+  }
+  const response = await get(
+    buildEndpoint("/v1/storefront/invoices/status/:invoiceId", {
+      invoiceId: normalizedInvoiceId
+    })
+  );
+  if (!response.success) {
+    return {
+      success: false,
+      message: response.message
+    };
+  }
+  if (!response.data?.invoice?.status) {
+    return {
+      success: false,
+      message: "Invalid invoice status response"
+    };
+  }
+  return {
+    success: true,
+    data: { status: response.data.invoice.status }
+  };
+}
+
+// ../sdk/src/modules/pages.ts
+var PAGES_CACHE_TTL = 5 * 60 * 1e3;
+async function getPages() {
+  const config = getConfig();
+  const response = await get(
+    buildEndpoint("/v1/storefront/shops/name/:storeSlug/pages", {
+      storeSlug: config.storeSlug
+    }),
+    {
+      cache: {
+        key: `pages:${config.storeSlug}`,
+        ttl: PAGES_CACHE_TTL,
+        staleWhileRevalidate: true
+      }
+    }
+  );
+  if (response.success && response.data) {
+    return {
+      success: true,
+      data: response.data.pages
+    };
+  }
+  return {
+    success: false,
+    message: response.message
+  };
+}
+async function getPage(slug) {
+  const config = getConfig();
+  const response = await get(
+    buildEndpoint("/v1/storefront/shops/name/:storeSlug/pages/:slug", {
+      storeSlug: config.storeSlug,
+      slug
+    }),
+    {
+      cache: {
+        key: `page:${config.storeSlug}:${slug}`,
+        ttl: PAGES_CACHE_TTL,
+        staleWhileRevalidate: true
+      }
+    }
+  );
+  if (response.success && response.data) {
+    return {
+      success: true,
+      data: response.data.page
+    };
+  }
+  return {
+    success: false,
+    message: response.message
+  };
+}
+
+// ../contracts/src/navigation.ts
+var NAVIGATION_MENU_SLOT_CONFIG = {
+  header: {
+    title: "Header",
+    aliases: ["Header Menu"]
+  },
+  footer: {
+    title: "Footer",
+    aliases: ["Footer Links", "Legal Links"]
+  }
+};
+function getNavigationMenuTitles(slot) {
+  const config = NAVIGATION_MENU_SLOT_CONFIG[slot];
+  return [config.title, ...config.aliases];
+}
+var NAVIGATION_MENU_SLOTS = Object.keys(NAVIGATION_MENU_SLOT_CONFIG);
+
+// ../sdk/src/modules/navigation.ts
+var NAVIGATION_CACHE_TTL = 5 * 60 * 1e3;
+async function getMenus() {
+  const config = getConfig();
+  const response = await get(
+    buildEndpoint("/v1/storefront/shops/name/:storeSlug/menus", {
+      storeSlug: config.storeSlug
+    }),
+    {
+      cache: {
+        key: `menus:${config.storeSlug}`,
+        ttl: NAVIGATION_CACHE_TTL,
+        staleWhileRevalidate: true
+      }
+    }
+  );
+  if (response.success && response.data) {
+    return {
+      success: true,
+      data: response.data.menus
+    };
+  }
+  return {
+    success: false,
+    message: response.message
+  };
+}
+async function getMenuByTitle(title) {
+  const config = getConfig();
+  const response = await get(
+    buildEndpoint("/v1/storefront/shops/name/:storeSlug/menus/:title", {
+      storeSlug: config.storeSlug,
+      title
+    }),
+    {
+      cache: {
+        key: `menu:${config.storeSlug}:${title}`,
+        ttl: NAVIGATION_CACHE_TTL,
+        staleWhileRevalidate: true
+      }
+    }
+  );
+  if (response.success && response.data) {
+    return {
+      success: true,
+      data: response.data.menu
+    };
+  }
+  return {
+    success: false,
+    message: response.message
+  };
+}
+async function getMenuBySlot(slot) {
+  const config = getConfig();
+  const response = await get(
+    buildEndpoint("/v1/storefront/shops/name/:storeSlug/menus/:title", {
+      storeSlug: config.storeSlug,
+      title: slot
+    }),
+    {
+      cache: {
+        key: `menu-slot:${config.storeSlug}:${slot}`,
+        ttl: NAVIGATION_CACHE_TTL,
+        staleWhileRevalidate: true
+      }
+    }
+  );
+  if (response.success && response.data) {
+    return {
+      success: true,
+      data: response.data.menu
+    };
+  }
+  return {
+    success: false,
+    message: response.message
+  };
+}
+function getMenuSlotTitles(slot) {
+  return getNavigationMenuTitles(slot);
+}
+
+// ../sdk/src/modules/analytics.ts
+function createPresenceConnectionId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `spx_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+}
+function getPresenceConnectionId(storeSlug) {
+  if (typeof window === "undefined") return null;
+  const storageKey = `presence_connection_${storeSlug}`;
+  const existing = getItem(storageKey);
+  if (existing && existing.trim()) {
+    return existing;
+  }
+  const nextId = createPresenceConnectionId();
+  setItem(storageKey, nextId);
+  return nextId;
+}
+async function trackPageView(cartValue, itemCount) {
+  if (!isInitialized()) return;
+  if (typeof document === "undefined") return;
+  const config = getConfig();
+  const connectionId = getPresenceConnectionId(config.storeSlug);
+  try {
+    const endpoint = buildEndpoint("/v1/storefront/shops/:storeSlug/ping", {
+      storeSlug: config.storeSlug
+    });
+    await fetch(`${config.apiBaseUrl}${endpoint}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        referer: document.referrer || void 0,
+        cart_value: cartValue ?? void 0,
+        item_count: itemCount ?? void 0,
+        connection_id: connectionId ?? void 0
+      })
+    });
+  } catch {
+  }
+}
+
+// ../sdk/src/utils/format.ts
+function createFormatter(currency, locale) {
+  const config = getConfig();
+  return new Intl.NumberFormat(locale ?? config.locale ?? "en-US", {
+    style: "currency",
+    currency: currency ?? config.currency ?? "USD"
+  });
+}
+function formatPrice(amount, currency, locale) {
+  const numericAmount = typeof amount === "string" ? parseFloat(amount) : amount;
+  if (Number.isNaN(numericAmount)) {
+    return createFormatter(currency, locale).format(0);
+  }
+  return createFormatter(currency, locale).format(numericAmount);
+}
+
+// ../sdk/src/modules/theme.ts
+async function fetchPublishedThemeSettings(shopSlug) {
+  const result = await get(
+    buildEndpoint("/v1/storefront/themes/builder/published/:shopSlug", { shopSlug })
+  );
+  return result.success && result.data ? result.data.settings : null;
+}
+function resolveDefaults(config) {
+  const resolved = {};
+  for (const [category, fields] of Object.entries(config.settings)) {
+    resolved[category] = {};
+    for (const [key, field] of Object.entries(fields)) {
+      resolved[category][key] = field.default;
+    }
+  }
+  return resolved;
+}
+function mergeSettings(defaults, overrides) {
+  const merged = { ...defaults };
+  for (const [category, fields] of Object.entries(overrides)) {
+    if (fields) {
+      merged[category] = { ...merged[category], ...fields };
+    }
+  }
+  return merged;
+}
+
+// ../sdk/src/index.ts
+function init(storeSlugOrOptions, options) {
+  if (typeof storeSlugOrOptions === "string") {
+    initConfig(storeSlugOrOptions, options);
+  } else {
+    initConfig(storeSlugOrOptions.storeId, storeSlugOrOptions);
+  }
+}
+var shoppex = {
+  // Initialization
+  init,
+  isInitialized,
+  getConfig,
+  // Store
+  getStore,
+  getStorefront,
+  getStoreLogoUrl,
+  getStoreBannerUrl,
+  resolveStoreByDomain,
+  // Products
+  getProducts,
+  getProduct,
+  getCategories,
+  // Cart
+  getCart,
+  getCartItemCount,
+  addToCart,
+  updateCartItem,
+  removeFromCart,
+  clearCart,
+  createCartBackup,
+  restoreCartFromBackup,
+  mergeBaskets,
+  moveBasketItem,
+  getCartStats,
+  validateCartIntegrity,
+  // Checkout
+  checkout,
+  buildCheckoutUrl,
+  buildCheckoutUrlSync,
+  // Affiliates
+  captureAffiliateFromUrl,
+  getAffiliateCode,
+  clearAffiliateCode,
+  // Coupons
+  validateCoupon,
+  // Reviews
+  getShopReviews,
+  // Search
+  searchProducts,
+  // Invoices
+  getInvoice,
+  getInvoiceStatus,
+  // Pages
+  getPages,
+  getPage,
+  // Navigation
+  getMenus,
+  getMenuBySlot,
+  getMenuByTitle,
+  getMenuSlotTitles,
+  // Analytics
+  trackPageView,
+  // Formatting
+  createFormatter,
+  formatPrice,
+  // Cache
+  clearCache,
+  invalidateCache,
+  getCacheStats,
+  // Theme settings helpers
+  fetchPublishedThemeSettings,
+  resolveDefaults,
+  mergeSettings
+};
+var src_default = shoppex;
+if (typeof window !== "undefined") {
+  window.shoppex = shoppex;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CartError,
+  NetworkError,
+  NotInitializedError,
+  ShoppexError,
+  ValidationError,
+  fetchPublishedThemeSettings,
+  getMenuBySlot,
+  getMenuByTitle,
+  getMenuSlotTitles,
+  mergeSettings,
+  resolveDefaults,
+  shoppex,
+  trackPageView
+});
+//# sourceMappingURL=index.cjs.map