@ecomiq/storefront 1.0.0 → 1.0.1

package/dist/chunks/client.js

@@ -0,0 +1,2046 @@
+"use client";
+import { z } from 'zod';
+import { QueryClient, hydrate, QueryClientProvider, useMutation, useQuery, useQueryClient, useInfiniteQuery } from '@tanstack/react-query';
+import React2, { createContext, useRef, useEffect, useContext, useState, useMemo, useCallback } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { toast } from 'sonner';
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+// src/core/client/store-api-errors.ts
+function isCartNotActiveApiError(error) {
+  if (!error || typeof error !== "object") return false;
+  const e = error;
+  if (e.status !== 400) return false;
+  const body = e.body;
+  const keys = body?.errors ? Object.keys(body.errors) : [];
+  return keys.includes("Carts.NotActive");
+}
+
+// src/core/client/store-api-client.ts
+var STORE_API_PATH = "/api/store";
+var serverRequestOriginGetter = null;
+var serverStoreIdGetter = null;
+var clientStoreIdGetter = null;
+function setServerRequestOrigin(getter) {
+  serverRequestOriginGetter = getter;
+}
+function setServerStoreId(storeId) {
+  serverStoreIdGetter = storeId?.trim() || null;
+}
+function setClientStoreId(storeId) {
+  if (typeof window === "undefined") return;
+  clientStoreIdGetter = storeId?.trim() || null;
+}
+async function getStoreApiBaseUrl() {
+  if (typeof window !== "undefined") {
+    return STORE_API_PATH;
+  }
+  if (serverRequestOriginGetter) {
+    return `${serverRequestOriginGetter.replace(/\/$/, "")}/${STORE_API_PATH.replace(/^\//, "")}`;
+  }
+  return STORE_API_PATH;
+}
+function createStoreApiClient(baseUrl) {
+  return new StoreApiClient(baseUrl);
+}
+async function getStoreApiClient() {
+  const baseUrl = await getStoreApiBaseUrl();
+  return new StoreApiClient(baseUrl);
+}
+var StoreApiClient = class {
+  baseUrl;
+  constructor(baseUrl = STORE_API_PATH) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  async request(path, init, options) {
+    const pathNorm = path.replace(/^\/+/, "");
+    const url = path.startsWith("http") ? path : `${this.baseUrl}/${pathNorm}`;
+    const headers = new Headers(init.headers ?? {});
+    headers.set("Content-Type", "application/json");
+    headers.set("Accept-Encoding", "identity");
+    const explicitStoreId = options?.xStoreId?.trim();
+    const runtimeStoreId = explicitStoreId || (typeof window === "undefined" ? serverStoreIdGetter : clientStoreIdGetter);
+    if (runtimeStoreId && !headers.has("x-store-id")) {
+      headers.set("X-Store-Id", runtimeStoreId);
+    }
+    if (options?.xStoreDomain) {
+      headers.set("X-Store-Domain", options.xStoreDomain);
+    }
+    if (options?.xCartId) {
+      headers.set("X-Cart-Token", options.xCartId);
+    }
+    const bearer = typeof options?.bearerToken === "string" && options.bearerToken.trim().length > 0 ? options.bearerToken.trim() : void 0;
+    if (bearer) {
+      headers.set(
+        "Authorization",
+        bearer.toLowerCase().startsWith("bearer ") ? bearer : `Bearer ${bearer}`
+      );
+    }
+    const isServer = typeof window === "undefined";
+    const res = await fetch(url, {
+      ...init,
+      headers,
+      credentials: isServer ? "same-origin" : "include",
+      ...options?.noStore ? { cache: "no-store" } : {},
+      ...options?.cacheKey && isServer && !options?.noStore ? {
+        next: {
+          revalidate: 60,
+          tags: [options.cacheKey]
+        }
+      } : {}
+    });
+    if (!res.ok) {
+      let body;
+      try {
+        const errorText = await res.text();
+        body = errorText ? JSON.parse(errorText) : void 0;
+      } catch {
+        body = void 0;
+      }
+      const msg = typeof body === "object" && body !== null && "title" in body && typeof body.title === "string" ? body.title : res.statusText || "Store API error";
+      const err = new Error(msg);
+      err.status = res.status;
+      err.body = body;
+      throw err;
+    }
+    const text = await res.text();
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  get(path, options) {
+    return this.request(path, { method: "GET" }, options);
+  }
+  post(path, data, options) {
+    return this.request(
+      path,
+      {
+        method: "POST",
+        body: data != null ? JSON.stringify(data) : void 0
+      },
+      options
+    );
+  }
+  patch(path, data, options) {
+    return this.request(path, {
+      method: "PATCH",
+      body: data != null ? JSON.stringify(data) : void 0
+    }, options);
+  }
+  put(path, data, options) {
+    return this.request(
+      path,
+      {
+        method: "PUT",
+        body: data != null ? JSON.stringify(data) : void 0
+      },
+      options
+    );
+  }
+  delete(path, options) {
+    return this.request(path, { method: "DELETE" }, options);
+  }
+};
+var storeApiClient = new StoreApiClient(STORE_API_PATH);
+var ProductVariantSchema = z.object({
+  id: z.coerce.string(),
+  name: z.string(),
+  storeId: z.string(),
+  productId: z.coerce.string(),
+  basePrice: z.number().positive().optional().nullable(),
+  comparePrice: z.number().positive().optional().nullable(),
+  //TODO: remove this field
+  originalPrice: z.number().positive().optional().nullable(),
+  costPrice: z.number().positive().optional().nullable(),
+  isDefault: z.boolean().optional().nullable(),
+  reserveStock: z.number().nonnegative().optional().nullable(),
+  weight: z.number().nonnegative().optional().nullable().default(0),
+  width: z.number().nonnegative().optional().nullable(),
+  height: z.number().nonnegative().optional().nullable(),
+  unitOfMeasure: z.string().optional().nullable(),
+  order: z.number().nonnegative().optional().nullable().default(0),
+  sku: z.string().optional().nullable(),
+  stock: z.number().nonnegative().optional().nullable(),
+  leadTime: z.string().optional().nullable(),
+  barCode: z.string().optional().nullable(),
+  shippingWeight: z.number().nonnegative().optional().nullable(),
+  images: z.array(z.string()).optional().nullable(),
+  attributes: z.array(z.string()).optional().nullable(),
+  variantStatus: z.string().optional().nullable(),
+  status: z.string().optional().nullable(),
+  createdOn: z.string().optional().nullable(),
+  updatedOn: z.string().optional().nullable(),
+  deletedOn: z.string().optional().nullable()
+});
+var ProductSchema = z.object({
+  id: z.coerce.string(),
+  name: z.string(),
+  images: z.array(z.object({
+    url: z.string().url(),
+    name: z.string().optional(),
+    isPrimary: z.boolean().optional()
+  })),
+  basePrice: z.number().positive().optional(),
+  salePrice: z.number().positive().optional(),
+  slug: z.string(),
+  description: z.string().optional(),
+  categories: z.array(z.object({
+    id: z.coerce.string(),
+    name: z.string(),
+    slug: z.string(),
+    logo: z.string().optional(),
+    icon: z.string().optional()
+  })).optional(),
+  tags: z.array(z.string()).optional(),
+  inStock: z.boolean().optional(),
+  variants: z.array(ProductVariantSchema).optional()
+});
+z.object({
+  items: z.array(ProductSchema),
+  meta: z.object({
+    total: z.number().int().positive(),
+    page: z.number().int().positive(),
+    pageSize: z.number().int().positive(),
+    hasNextPage: z.boolean()
+  })
+});
+z.object({
+  category: z.string().optional(),
+  search: z.string().optional(),
+  minPrice: z.number().positive().optional(),
+  maxPrice: z.number().positive().optional(),
+  inStock: z.boolean().optional(),
+  sortBy: z.enum(["name", "price", "createdAt"]).optional(),
+  sortOrder: z.enum(["asc", "desc"]).optional(),
+  page: z.number().int().positive().optional(),
+  limit: z.number().int().positive().optional()
+});
+var StorefrontProductSchema = z.object({
+  id: z.coerce.string(),
+  name: z.string(),
+  slug: z.string(),
+  productType: z.string().optional().nullable(),
+  imageUrl: z.string().optional().nullable(),
+  price: z.number().nonnegative(),
+  compareAtPrice: z.number().nonnegative().optional().nullable(),
+  variantCount: z.number().int().nonnegative().optional().default(0),
+  isAvailable: z.boolean(),
+  totalInventory: z.number().int().nonnegative(),
+  bundleItemsCount: z.number().int().nonnegative().optional().default(0),
+  brand: z.string().optional().nullable(),
+  category: z.string().optional().nullable(),
+  status: z.string().optional().nullable(),
+  tags: z.array(z.string()).optional().nullable()
+});
+var StorefrontFacetSchema = z.object({
+  value: z.string(),
+  count: z.number().int().nonnegative()
+});
+var StorefrontProductsResponseSchema = z.object({
+  pageIndex: z.number().int().positive(),
+  pageSize: z.number().int().positive(),
+  totalCount: z.number().int().nonnegative(),
+  totalPages: z.number().int().nonnegative(),
+  products: z.array(StorefrontProductSchema),
+  categories: z.array(StorefrontFacetSchema).optional().default([]),
+  brands: z.array(StorefrontFacetSchema).optional().default([]),
+  minPrice: z.number().nonnegative().optional().nullable(),
+  maxPrice: z.number().nonnegative().optional().nullable()
+});
+var StorefrontProductsParamsSchema = z.object({
+  page: z.number().int().positive().optional().default(1),
+  pageSize: z.number().int().positive().optional().default(20),
+  sort: z.enum(["price_asc", "price_desc", "name_asc", "name_desc", "newest"]).optional().default("price_asc"),
+  sellerId: z.string().optional(),
+  search: z.string().optional(),
+  collection: z.string().optional(),
+  category: z.string().optional(),
+  brand: z.string().optional(),
+  productType: z.string().optional(),
+  inStock: z.boolean().optional(),
+  minPrice: z.number().nonnegative().optional(),
+  maxPrice: z.number().nonnegative().optional()
+});
+var StorefrontVariantOptionSchema = z.object({
+  key: z.string(),
+  name: z.string(),
+  value: z.string()
+});
+var StorefrontProductImageSchema = z.object({
+  url: z.string(),
+  name: z.string().optional().nullable(),
+  order: z.number().int().nonnegative().optional()
+});
+var StorefrontVariantSchema = z.object({
+  id: z.coerce.string().optional().default(""),
+  sku: z.string(),
+  status: z.string().optional().nullable(),
+  price: z.number().nonnegative(),
+  compareAtPrice: z.number().nonnegative().optional().nullable(),
+  quantity: z.number().int().nonnegative(),
+  options: z.array(StorefrontVariantOptionSchema).optional().default([]),
+  images: z.array(StorefrontProductImageSchema).optional().default([])
+});
+var StorefrontPriceTierSchema = z.object({
+  variantId: z.coerce.string(),
+  minQuantity: z.number().int().positive(),
+  maxQuantity: z.number().int().positive().optional().nullable(),
+  unitPrice: z.number().nonnegative()
+});
+var StorefrontBundleItemSchema = z.object({
+  productId: z.coerce.string(),
+  variantId: z.coerce.string(),
+  productName: z.string(),
+  variantName: z.string().optional().nullable(),
+  sku: z.string().optional().nullable(),
+  brand: z.string().optional().nullable(),
+  imageUrl: z.string().optional().nullable(),
+  quantity: z.number().int(),
+  availableStock: z.number().int().optional().default(0),
+  allowBackorders: z.boolean().optional().default(false),
+  requiresShipping: z.boolean().optional().default(true)
+});
+var StorefrontProductDetailSchema = z.object({
+  id: z.coerce.string(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.string().optional().nullable(),
+  productType: z.string().optional().nullable(),
+  status: z.string().optional().nullable(),
+  imageUrl: z.string().optional().nullable(),
+  price: z.number().nonnegative(),
+  compareAtPrice: z.number().nonnegative().optional().nullable(),
+  isAvailable: z.boolean(),
+  totalInventory: z.number().int().nonnegative(),
+  brand: z.string().optional().nullable(),
+  category: z.string().optional().nullable(),
+  categoryId: z.coerce.string().optional().nullable(),
+  tags: z.array(z.string()).optional().nullable(),
+  specifications: z.array(z.record(z.string(), z.unknown())).optional().default([]),
+  variants: z.array(StorefrontVariantSchema).optional().default([]),
+  images: z.array(StorefrontProductImageSchema).optional().default([]),
+  bundleItems: z.array(StorefrontBundleItemSchema).optional().default([]),
+  priceTiers: z.array(StorefrontPriceTierSchema).optional().default([]),
+  createdAt: z.string().optional().nullable(),
+  updatedAt: z.string().optional().nullable()
+});
+
+// src/core/client/store-api-product.service.ts
+async function getStorefrontProducts(params, cacheKey) {
+  const parsed = StorefrontProductsParamsSchema.parse(params ?? {});
+  const searchParams = new URLSearchParams();
+  searchParams.set("page", String(parsed.page));
+  searchParams.set("pageSize", String(parsed.pageSize));
+  if (parsed.sort) searchParams.set("sort", parsed.sort);
+  if (parsed.sellerId) searchParams.set("sellerId", parsed.sellerId);
+  if (parsed.search) searchParams.set("search", parsed.search);
+  if (parsed.collection) searchParams.set("collection", parsed.collection);
+  if (parsed.category) searchParams.set("category", parsed.category);
+  if (parsed.brand) searchParams.set("brand", parsed.brand);
+  if (parsed.productType) searchParams.set("productType", parsed.productType);
+  if (parsed.inStock != null) searchParams.set("inStock", String(parsed.inStock));
+  if (parsed.minPrice != null) searchParams.set("minPrice", String(parsed.minPrice));
+  if (parsed.maxPrice != null) searchParams.set("maxPrice", String(parsed.maxPrice));
+  const path = `products?${searchParams.toString()}`;
+  const client = await getStoreApiClient();
+  const response = await client.get(path, {
+    cacheKey
+  });
+  return StorefrontProductsResponseSchema.parse(response);
+}
+async function getStorefrontProductBySlug(slug) {
+  const path = `products/${encodeURIComponent(slug)}`;
+  const client = await getStoreApiClient();
+  const response = await client.get(path);
+  return StorefrontProductDetailSchema.parse(response);
+}
+var StorefrontCollectionSchema = z.object({
+  id: z.coerce.string(),
+  slug: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  imageUrl: z.string().nullable().optional(),
+  type: z.string(),
+  productCount: z.number().int().nonnegative()
+});
+var StorefrontCollectionsResponseSchema = z.array(StorefrontCollectionSchema);
+var StorefrontCollectionDetailSchema = StorefrontCollectionSchema;
+
+// src/core/client/store-api-collection.service.ts
+async function getStorefrontCollections() {
+  const client = await getStoreApiClient();
+  const response = await client.get("collections");
+  return StorefrontCollectionsResponseSchema.parse(response);
+}
+async function getStorefrontCollectionBySlug(slug) {
+  const client = await getStoreApiClient();
+  const response = await client.get(
+    `collections/by-slug/${encodeURIComponent(slug)}`
+  );
+  return StorefrontCollectionDetailSchema.parse(response);
+}
+var StorefrontPageListItemSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  layout: z.string()
+});
+var StorefrontPageSeoSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional()
+}).optional();
+var StorefrontPageSettingsSchema = z.object({
+  seo: StorefrontPageSeoSchema,
+  html: z.string().optional(),
+  title: z.string().optional()
+}).catchall(z.unknown());
+var StorefrontPageBlockSchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  order: z.number(),
+  settings: z.record(z.unknown()).optional()
+});
+var StorefrontPageSectionSchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  order: z.number(),
+  settings: z.record(z.unknown()).optional(),
+  blocks: z.array(StorefrontPageBlockSchema).optional().default([])
+});
+var StorefrontPageDetailSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  layout: z.string(),
+  settings: StorefrontPageSettingsSchema.optional(),
+  sections: z.array(StorefrontPageSectionSchema).optional()
+});
+async function getStorefrontPages() {
+  const client = await getStoreApiClient();
+  const response = await client.get("pages");
+  return z.array(StorefrontPageListItemSchema).parse(response);
+}
+async function getStorefrontPageBySlug(slug) {
+  const path = `pages/${encodeURIComponent(slug)}`;
+  const client = await getStoreApiClient();
+  const response = await client.get(path);
+  return StorefrontPageDetailSchema.parse(response);
+}
+async function getStorefrontPagePreview(slug, token) {
+  const path = `pages/${encodeURIComponent(slug)}/preview?token=${encodeURIComponent(token)}`;
+  const client = await getStoreApiClient();
+  const response = await client.get(path);
+  return StorefrontPageDetailSchema.parse(response);
+}
+var CartBuyerRequestSchema = z.object({
+  email: z.string().email(),
+  firstName: z.string().min(1),
+  lastName: z.string().min(1),
+  phone: z.string().min(1)
+});
+var CartCreateRequestSchema = z.object({
+  currencyCode: z.string(),
+  salesChannelId: z.string(),
+  email: z.string().email()
+});
+var CartAddressSchema = z.object({
+  name: z.string().min(1),
+  address1: z.string().min(1),
+  city: z.string().min(1),
+  countryCode: z.string().min(2),
+  company: z.string().nullable().optional(),
+  address2: z.string().nullable().optional(),
+  province: z.string().nullable().optional(),
+  postalCode: z.string().nullable().optional(),
+  district: z.string().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  latitude: z.number().nullable().optional(),
+  longitude: z.number().nullable().optional(),
+  geo: z.object({
+    departmentCode: z.string().nullable().optional(),
+    provinceCode: z.string().nullable().optional(),
+    districtCode: z.string().nullable().optional()
+  }).nullable().optional()
+});
+var CartAddressesRequestSchema = z.object({
+  shippingAddress: CartAddressSchema,
+  billingAddress: CartAddressSchema
+});
+var CartItemModifierRequestSchema = z.object({
+  modifierGroupId: z.coerce.string().min(1),
+  optionIds: z.array(z.coerce.string().min(1)).optional().default([])
+});
+var CartItemRequestSchema = z.object({
+  variantId: z.coerce.string().min(1),
+  quantity: z.number().int().positive(),
+  modifiers: z.array(CartItemModifierRequestSchema).optional()
+});
+var CartCouponRequestSchema = z.object({
+  code: z.string().min(1)
+});
+z.object({
+  subtotal: z.number(),
+  discount: z.number(),
+  tax: z.number(),
+  warranty: z.number().optional().default(0),
+  total: z.number()
+});
+z.object({
+  name: z.string().nullable().optional(),
+  address1: z.string(),
+  city: z.string(),
+  countryCode: z.string(),
+  company: z.string().nullable().optional(),
+  address2: z.string().nullable().optional(),
+  province: z.string().nullable().optional(),
+  postalCode: z.string().nullable().optional(),
+  district: z.string().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  latitude: z.number().nullable().optional(),
+  longitude: z.number().nullable().optional(),
+  geo: z.object({
+    departmentCode: z.string().nullable().optional(),
+    provinceCode: z.string().nullable().optional(),
+    districtCode: z.string().nullable().optional()
+  }).nullable().optional()
+});
+var CartResponseBundleItemSchema = z.object({
+  productId: z.coerce.string(),
+  variantId: z.coerce.string(),
+  productName: z.string(),
+  variantName: z.string().nullable().optional(),
+  sku: z.string().nullable().optional(),
+  brand: z.string().nullable().optional(),
+  imageUrl: z.string().nullable().optional(),
+  quantity: z.number().int()
+});
+var CartResponseItemSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  variantLabel: z.string().nullable().optional(),
+  thumbnail: z.string().nullable().optional(),
+  quantity: z.number().int(),
+  variantId: z.coerce.string(),
+  variantSku: z.string().nullable().optional(),
+  unitPrice: z.number(),
+  bundleItems: z.array(CartResponseBundleItemSchema).optional().default([])
+});
+z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  total: z.number(),
+  estimatedDays: z.number().int().nullable().optional(),
+  pickupPointId: z.string().nullable().optional(),
+  scheduledDate: z.string().nullable().optional(),
+  scheduledTime: z.string().nullable().optional()
+});
+var CartResponseSchema = z.object({
+  id: z.string(),
+  regionId: z.string().nullable().optional(),
+  salesChannelId: z.string().nullable().optional(),
+  email: z.string().email().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  firstName: z.string().nullable().optional(),
+  lastName: z.string().nullable().optional(),
+  currencyCode: z.string(),
+  completedAt: z.string().nullable().optional(),
+  shippingAddress: z.unknown().nullable().optional(),
+  billingAddress: z.unknown().nullable().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional().default({}),
+  promotionCodes: z.array(z.string()).optional().default([]),
+  items: z.array(CartResponseItemSchema).optional().default([]),
+  shippingMethods: z.array(z.unknown()).optional().default([]),
+  totals: z.object({
+    discountTotal: z.number(),
+    shippingTotal: z.number(),
+    subtotal: z.number(),
+    taxTotal: z.number(),
+    total: z.number(),
+    warrantyTotal: z.number()
+  })
+});
+var CartCheckoutRequestSchema = z.object({
+  paymentMethodCode: z.string().min(1),
+  externalRef: z.string().min(1),
+  receiptUrl: z.string().min(1).optional()
+});
+var CartCheckoutPaymentActionSchema = z.object({
+  publicConfiguration: z.object({
+    publishableKey: z.string().nullable().optional(),
+    checkoutMode: z.string().nullable().optional(),
+    phoneNumber: z.string().nullable().optional(),
+    accountHolder: z.string().nullable().optional(),
+    qrImageUrl: z.string().nullable().optional()
+  }).passthrough().nullable().optional(),
+  url: z.string().nullable().optional(),
+  html: z.string().nullable().optional(),
+  clientSecret: z.string().nullable().optional(),
+  qrCode: z.string().nullable().optional(),
+  expiresAt: z.string().nullable().optional()
+}).passthrough();
+var CartCheckoutPaymentSchema = z.object({
+  transactionId: z.string(),
+  paymentMethodCode: z.string(),
+  providerId: z.string().nullable().optional(),
+  status: z.string(),
+  amount: z.number(),
+  reference: z.string(),
+  actionType: z.string(),
+  receiptUrl: z.string().nullable().optional(),
+  action: CartCheckoutPaymentActionSchema.nullable().optional()
+}).passthrough();
+var CartCheckoutResponseSchema = z.object({
+  publicKey: z.string().optional(),
+  publishableKey: z.string().optional(),
+  stripePublicKey: z.string().optional(),
+  clientSecret: z.string().optional(),
+  intentClientSecret: z.string().optional(),
+  orderId: z.coerce.string().optional(),
+  orderGroup: z.string().optional(),
+  orderIds: z.array(z.coerce.string()).optional(),
+  /** Payload de pago (embedded, redirect, etc.) */
+  payment: CartCheckoutPaymentSchema.optional(),
+  cart: z.unknown().optional()
+}).passthrough();
+var CartPaymentReceiptResponseSchema = z.object({
+  id: z.string(),
+  url: z.string()
+});
+var CartPaymentMethodSchema = z.object({
+  code: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  kind: z.string(),
+  isActive: z.boolean(),
+  isDefault: z.boolean(),
+  isManual: z.boolean(),
+  sortOrder: z.number(),
+  phoneNumber: z.string().nullable().optional(),
+  accountHolder: z.string().nullable().optional(),
+  qrImageUrl: z.string().nullable().optional()
+});
+var CartPaymentMethodsResponseSchema = z.object({
+  methods: z.array(CartPaymentMethodSchema)
+});
+var CartCheckoutReadResponseSchema = z.object({
+  cart: CartResponseSchema,
+  paymentMethods: CartPaymentMethodsResponseSchema
+});
+var ShippingRateSchema = z.object({
+  shippingMethodId: z.string(),
+  name: z.string(),
+  displayName: z.string().optional(),
+  type: z.string().optional(),
+  price: z.number(),
+  currency: z.string().optional(),
+  sortOrder: z.number().optional(),
+  rateId: z.string(),
+  description: z.string().nullable().optional(),
+  deliveryLocationId: z.string().nullable().optional(),
+  deliveryLocationName: z.string().nullable().optional(),
+  estimatedDeliveryDays: z.number().nullable().optional(),
+  serviceCode: z.string().nullable().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+}).passthrough();
+var ShippingOptionGroupSchema = z.object({
+  sellerId: z.string(),
+  shippingProfileId: z.string().nullable().optional(),
+  orderAmount: z.number().optional(),
+  totalWeight: z.number().optional(),
+  itemIds: z.array(z.string()).optional(),
+  rates: z.array(ShippingRateSchema)
+}).passthrough();
+var ShippingOptionsResponseSchema = z.object({
+  groups: z.array(ShippingOptionGroupSchema)
+});
+var CartShippingMethodPutRequestSchema = z.object({
+  rateId: z.string().min(1),
+  shippingMethodId: z.string().min(1),
+  serviceCode: z.string().nullable().optional(),
+  sellerId: z.string().nullable().optional(),
+  shippingProfileId: z.string().nullable().optional(),
+  locationId: z.string().nullable().optional(),
+  pickupPointId: z.string().nullable().optional(),
+  scheduledDate: z.string().nullable().optional(),
+  scheduledTime: z.string().nullable().optional()
+});
+
+// src/core/client/store-api-cart.service.ts
+async function createCart(data) {
+  const payload = CartCreateRequestSchema.parse(data);
+  const client = await getStoreApiClient();
+  const response = await client.post("carts", payload);
+  return CartResponseSchema.parse(response);
+}
+async function getCart(cartId) {
+  if (!cartId) throw new Error("cartId is required");
+  const client = await getStoreApiClient();
+  const response = await client.get(`carts/${cartId}`);
+  return CartResponseSchema.parse(response);
+}
+async function addCartItem(data, cartId) {
+  if (!cartId) throw new Error("cartId is required");
+  const payload = CartItemRequestSchema.parse(data);
+  const variantId = Number(payload.variantId);
+  if (!Number.isSafeInteger(variantId) || variantId <= 0) {
+    throw new Error("variantId must be a valid public id");
+  }
+  const modifiers = payload.modifiers?.map((modifier) => {
+    const modifierGroupId = Number(modifier.modifierGroupId);
+    const optionIds = modifier.optionIds.map((optionId) => Number(optionId));
+    if (!Number.isSafeInteger(modifierGroupId) || modifierGroupId <= 0 || optionIds.some((optionId) => !Number.isSafeInteger(optionId) || optionId <= 0)) {
+      throw new Error("modifiers must use valid public ids");
+    }
+    return { modifierGroupId, optionIds };
+  });
+  const client = await getStoreApiClient();
+  const response = await client.post(`carts/${cartId}/items`, {
+    ...payload,
+    variantId,
+    ...modifiers ? { modifiers } : {}
+  });
+  return CartResponseSchema.parse(response);
+}
+async function patchCartBuyer(data, cartId) {
+  if (!cartId) throw new Error("cartId is required");
+  const payload = CartBuyerRequestSchema.parse(data);
+  const client = await getStoreApiClient();
+  const response = await client.patch(
+    `carts/${cartId}/buyer`,
+    payload
+  );
+  return CartResponseSchema.parse(response);
+}
+async function patchCartAddresses(data, cartId) {
+  if (!cartId) throw new Error("cartId is required");
+  const payload = CartAddressesRequestSchema.parse(data);
+  const client = await getStoreApiClient();
+  const response = await client.patch(
+    `carts/${cartId}/addresses`,
+    payload
+  );
+  return CartResponseSchema.parse(response);
+}
+async function addCartCoupon(cartId, data) {
+  if (!cartId) throw new Error("cartId is required");
+  const payload = CartCouponRequestSchema.parse(data);
+  const client = await getStoreApiClient();
+  const response = await client.post(
+    `carts/${cartId}/promotion-codes`,
+    payload
+  );
+  return CartResponseSchema.parse(response);
+}
+async function removeCartCoupon(cartId, code) {
+  if (!cartId) throw new Error("cartId is required");
+  if (!code.trim()) throw new Error("code is required");
+  const client = await getStoreApiClient();
+  const response = await client.delete(
+    `carts/${cartId}/promotion-codes/${encodeURIComponent(code.trim())}`
+  );
+  return CartResponseSchema.parse(response);
+}
+async function checkoutCart(data, cartId) {
+  if (!cartId) throw new Error("cartId is required");
+  const payload = CartCheckoutRequestSchema.parse(data);
+  const client = await getStoreApiClient();
+  const response = await client.post(
+    `carts/${cartId}/checkout`,
+    payload
+  );
+  return CartCheckoutResponseSchema.parse(response);
+}
+async function uploadPaymentReceipt(cartId, file) {
+  if (!cartId) throw new Error("cartId is required");
+  const baseUrl = await getStoreApiBaseUrl();
+  const form = new FormData();
+  form.set("file", file);
+  const response = await fetch(
+    `${baseUrl.replace(/\/$/, "")}/carts/${encodeURIComponent(cartId)}/payment-receipt`,
+    {
+      method: "POST",
+      body: form,
+      ...typeof window === "undefined" && { cache: "no-store" }
+    }
+  );
+  if (!response.ok) {
+    let body;
+    try {
+      const errorText = await response.text();
+      body = errorText ? JSON.parse(errorText) : void 0;
+    } catch {
+      body = void 0;
+    }
+    const message = typeof body === "object" && body !== null && "title" in body && typeof body.title === "string" ? body.title : response.statusText || "Store API error";
+    const error = new Error(message);
+    error.status = response.status;
+    error.body = body;
+    throw error;
+  }
+  return CartPaymentReceiptResponseSchema.parse(await response.json());
+}
+async function getCartCheckout(cartId) {
+  if (!cartId) throw new Error("cartId is required");
+  const client = await getStoreApiClient();
+  const response = await client.get(`carts/${cartId}/checkout`);
+  return CartCheckoutReadResponseSchema.parse(response);
+}
+async function getShippingOptions(cartId, postalCode) {
+  if (!cartId) throw new Error("cartId is required");
+  if (!postalCode?.trim()) throw new Error("postalCode is required");
+  const client = await getStoreApiClient();
+  const q = new URLSearchParams({ postalCode: postalCode.trim() });
+  const response = await client.get(
+    `carts/${cartId}/shipping-options?${q.toString()}`
+  );
+  return ShippingOptionsResponseSchema.parse(response);
+}
+async function putCartShippingMethod(cartId, data) {
+  if (!cartId) throw new Error("cartId is required");
+  const payload = CartShippingMethodPutRequestSchema.parse(data);
+  const client = await getStoreApiClient();
+  const response = await client.put(
+    `carts/${cartId}/shipping-method`,
+    payload
+  );
+  return CartResponseSchema.parse(response);
+}
+async function getCartPaymentMethods(cartId) {
+  if (!cartId) throw new Error("cartId is required");
+  const { paymentMethods } = await getCartCheckout(cartId);
+  return paymentMethods;
+}
+var CustomerRegisterRequestSchema = z.object({
+  email: z.string().email(),
+  firstName: z.string().trim().min(1),
+  lastName: z.string().trim().min(1),
+  countryIsoCode: z.string().trim().length(2),
+  password: z.string(),
+  phone: z.string().trim().optional()
+});
+var CustomerAddressSchema = z.object({
+  /** Presente en listados cuando el upstream expone el id para PUT/DELETE. */
+  id: z.string().optional(),
+  addressKey: z.string(),
+  countryIsoCode: z.string(),
+  addressLine: z.string(),
+  addressNumber: z.string(),
+  department: z.string(),
+  province: z.string(),
+  district: z.string(),
+  phone: z.string(),
+  cellPhone: z.string(),
+  postalCode: z.string(),
+  reference: z.string(),
+  latitude: z.number().nullable(),
+  longitude: z.number().nullable(),
+  isDefault: z.boolean()
+});
+var CustomerAddressUpsertSchema = CustomerAddressSchema.omit({ id: true });
+var CustomerMeSchema = z.object({
+  id: z.string(),
+  storeId: z.string(),
+  email: z.string().email(),
+  firstName: z.string(),
+  lastName: z.string(),
+  phone: z.string(),
+  identificationNumber: z.string().nullable(),
+  identificationType: z.string().nullable(),
+  entityName: z.string().nullable(),
+  dateOfBirth: z.string().nullable(),
+  gender: z.string().nullable(),
+  countryIsoCode: z.string(),
+  role: z.string().nullable(),
+  companyName: z.string().nullable(),
+  consent: z.boolean(),
+  userId: z.string(),
+  customerType: z.string(),
+  status: z.string(),
+  entityIdentificationNumber: z.string().nullable(),
+  defaultAddressId: z.string().nullable(),
+  metadata: z.unknown().nullable(),
+  totalOrders: z.number(),
+  avgOrders: z.number(),
+  lastOrderId: z.string().nullable(),
+  lastOrderDate: z.string().nullable(),
+  loyaltyPoints: z.number(),
+  addresses: z.array(CustomerAddressSchema),
+  createdOn: z.string(),
+  updatedOn: z.string().nullable()
+});
+var CustomerProfilePatchSchema = z.object({
+  firstName: z.string().trim().min(1),
+  lastName: z.string().trim().min(1),
+  phone: z.string().trim(),
+  identificationNumber: z.string().nullable(),
+  identificationType: z.string().nullable(),
+  entityName: z.string().nullable(),
+  entityIdentificationNumber: z.string().nullable(),
+  gender: z.string().nullable(),
+  role: z.string().nullable(),
+  companyName: z.string().nullable(),
+  dateOfBirth: z.string().nullable(),
+  consent: z.boolean(),
+  countryIsoCode: z.string().trim().length(2)
+});
+function customerMeToProfilePatch(me) {
+  return {
+    firstName: me.firstName,
+    lastName: me.lastName,
+    phone: me.phone ?? "",
+    identificationNumber: me.identificationNumber,
+    identificationType: me.identificationType,
+    entityName: me.entityName,
+    entityIdentificationNumber: me.entityIdentificationNumber,
+    gender: me.gender,
+    role: me.role,
+    companyName: me.companyName,
+    dateOfBirth: me.dateOfBirth,
+    consent: me.consent,
+    countryIsoCode: me.countryIsoCode || "PE"
+  };
+}
+function customerAuthOptions(accessToken) {
+  const token = typeof accessToken === "string" && accessToken.trim().length > 0 ? accessToken.trim() : void 0;
+  return token ? { bearerToken: token } : {};
+}
+async function registerCustomer(data) {
+  const payload = CustomerRegisterRequestSchema.parse(data);
+  const client = await getStoreApiClient();
+  return client.post("customer/register", payload);
+}
+async function getCustomerAddresses(accessToken) {
+  const client = await getStoreApiClient();
+  const token = typeof accessToken === "string" && accessToken.trim().length > 0 ? accessToken.trim() : void 0;
+  const response = await client.get("customer/addresses", {
+    ...token ? { bearerToken: token } : {}
+  });
+  return z.array(CustomerAddressSchema).parse(response);
+}
+async function createCustomerAddress(data, accessToken) {
+  const client = await getStoreApiClient();
+  const token = typeof accessToken === "string" && accessToken.trim().length > 0 ? accessToken.trim() : void 0;
+  const payload = CustomerAddressUpsertSchema.parse(data);
+  return client.post("customer/addresses", payload, {
+    ...token ? { bearerToken: token } : {}
+  });
+}
+async function updateCustomerAddress(addressId, data, accessToken) {
+  const client = await getStoreApiClient();
+  const token = typeof accessToken === "string" && accessToken.trim().length > 0 ? accessToken.trim() : void 0;
+  const payload = CustomerAddressUpsertSchema.parse(data);
+  const id = addressId.trim();
+  if (!id) throw new Error("addressId requerido");
+  return client.put(`customer/addresses/${encodeURIComponent(id)}`, payload, {
+    ...token ? { bearerToken: token } : {}
+  });
+}
+async function deleteCustomerAddress(addressId, accessToken) {
+  const client = await getStoreApiClient();
+  const token = typeof accessToken === "string" && accessToken.trim().length > 0 ? accessToken.trim() : void 0;
+  const id = addressId.trim();
+  if (!id) throw new Error("addressId requerido");
+  return client.delete(`customer/addresses/${encodeURIComponent(id)}`, {
+    ...token ? { bearerToken: token } : {}
+  });
+}
+async function getCustomerMe(accessToken) {
+  const client = await getStoreApiClient();
+  const response = await client.get("customer", customerAuthOptions(accessToken));
+  return CustomerMeSchema.parse(response);
+}
+async function patchCustomer(data, accessToken) {
+  const client = await getStoreApiClient();
+  const payload = CustomerProfilePatchSchema.parse(data);
+  await client.patch("customer", payload, customerAuthOptions(accessToken));
+}
+var CustomerOrderShippingAddressSchema = z.object({
+  name: z.string().nullable().optional(),
+  company: z.string().nullable().optional(),
+  address1: z.string(),
+  address2: z.string().nullable().optional(),
+  city: z.string().nullable().optional(),
+  countryCode: z.string(),
+  province: z.string().nullable().optional(),
+  postalCode: z.string().nullable().optional(),
+  district: z.string().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  latitude: z.number().nullable().optional(),
+  longitude: z.number().nullable().optional(),
+  metadata: z.record(z.unknown()).nullable().optional()
+}).passthrough();
+var CustomerOrderLineItemSchema = z.object({
+  id: z.string(),
+  orderId: z.coerce.string(),
+  productId: z.coerce.string().nullable(),
+  variantId: z.coerce.string().nullable(),
+  title: z.string(),
+  subtitle: z.string().nullable().optional(),
+  thumbnail: z.string().nullable().optional(),
+  variantTitle: z.string().nullable().optional(),
+  productHandle: z.string().nullable().optional(),
+  quantity: z.number(),
+  unitPrice: z.number(),
+  total: z.number(),
+  status: z.string()
+});
+var CustomerOrderListItemSchema = z.object({
+  orderId: z.coerce.string(),
+  orderNumber: z.string(),
+  orderGroup: z.string(),
+  orderIds: z.array(z.coerce.string()),
+  status: z.string(),
+  total: z.number(),
+  totalPaid: z.number(),
+  currencyCode: z.string(),
+  orderDate: z.string(),
+  createdOn: z.string(),
+  updatedOn: z.string().nullable().optional(),
+  paymentAt: z.string().nullable().optional(),
+  shippingAddress: CustomerOrderShippingAddressSchema.nullable().optional(),
+  shippingAddressSummary: z.string().nullable().optional(),
+  items: z.array(CustomerOrderLineItemSchema)
+});
+var CustomerOrderPaymentSchema = z.object({
+  id: z.string(),
+  paymentMethod: z.string(),
+  paymentCode: z.string(),
+  amount: z.number(),
+  paymentStatus: z.string(),
+  receiptUrl: z.string().nullable().optional(),
+  createdOn: z.string()
+});
+var CustomerOrderStatusTimelineSchema = z.object({
+  key: z.string(),
+  label: z.string(),
+  occurredAt: z.string(),
+  description: z.string().nullable().optional(),
+  status: z.string(),
+  source: z.string()
+});
+var CustomerOrderDetailSchema = z.object({
+  id: z.coerce.string(),
+  orderNumber: z.string(),
+  orderGroup: z.string(),
+  status: z.string(),
+  total: z.number(),
+  totalPaid: z.number(),
+  currencyCode: z.string(),
+  orderDate: z.string(),
+  createdOn: z.string(),
+  updatedOn: z.string().nullable().optional(),
+  paymentAt: z.string().nullable().optional(),
+  subTotal: z.number(),
+  discount: z.number(),
+  shipping: z.number(),
+  tax: z.number(),
+  email: z.string(),
+  phone: z.string(),
+  firstName: z.string(),
+  lastName: z.string(),
+  shippingAddress: CustomerOrderShippingAddressSchema.nullable().optional(),
+  shippingAddressSummary: z.string().nullable().optional(),
+  billingAddress: CustomerOrderShippingAddressSchema.nullable().optional(),
+  items: z.array(CustomerOrderLineItemSchema),
+  payments: z.array(CustomerOrderPaymentSchema),
+  statusTimeline: z.array(CustomerOrderStatusTimelineSchema)
+});
+function authOptions(accessToken) {
+  const token = typeof accessToken === "string" && accessToken.trim().length > 0 ? accessToken.trim() : void 0;
+  return token ? { bearerToken: token } : {};
+}
+async function getCustomerOrders(accessToken) {
+  const client = await getStoreApiClient();
+  const response = await client.get("customer/orders", authOptions(accessToken));
+  return z.array(CustomerOrderListItemSchema).parse(response);
+}
+async function getCustomerOrder(orderId, accessToken) {
+  const client = await getStoreApiClient();
+  const id = orderId.trim();
+  if (!id) throw new Error("orderId requerido");
+  const response = await client.get(
+    `customer/orders/${encodeURIComponent(id)}`,
+    authOptions(accessToken)
+  );
+  return CustomerOrderDetailSchema.parse(response);
+}
+var StorefrontOrderAddressSchema = z.object({
+  address1: z.string().optional(),
+  address2: z.string().optional(),
+  city: z.string().optional(),
+  province: z.string().optional(),
+  country: z.string().optional(),
+  zip: z.string().optional(),
+  phone: z.string().optional(),
+  firstName: z.string().optional(),
+  lastName: z.string().optional()
+}).passthrough();
+var OrderDraftItemSchema = z.object({
+  id: z.string(),
+  productId: z.coerce.string().nullable().optional(),
+  sellerId: z.string().nullable().optional(),
+  shippingProfileId: z.string().nullable().optional(),
+  variantId: z.coerce.string().nullable().optional(),
+  title: z.string(),
+  subtitle: z.string().nullable().optional(),
+  thumbnail: z.string().nullable().optional(),
+  quantity: z.number().optional().default(1),
+  unitPrice: z.number().optional().default(0),
+  subTotal: z.number().optional().default(0),
+  discount: z.number().optional().default(0),
+  shipping: z.number().optional().default(0),
+  tax: z.number().optional().default(0),
+  warranty: z.number().optional().default(0),
+  total: z.number().optional().default(0),
+  requiresShipping: z.boolean().optional().default(true),
+  isTaxInclusive: z.boolean().optional().default(true),
+  metadata: z.record(z.unknown()).optional().default({})
+});
+var OrderDraftShippingMethodSchema = z.object({
+  id: z.string(),
+  name: z.string().optional().default(""),
+  description: z.string().nullable().optional(),
+  subtotal: z.number().optional().default(0),
+  discountTotal: z.number().optional().default(0),
+  taxTotal: z.number().optional().default(0),
+  total: z.number().optional().default(0),
+  isTaxInclusive: z.boolean().optional().default(true),
+  sellerId: z.string().nullable().optional(),
+  shippingProfileId: z.string().nullable().optional(),
+  shippingMethodId: z.string().nullable().optional(),
+  connectionId: z.string().nullable().optional(),
+  providerName: z.string().nullable().optional(),
+  trackingCode: z.string().nullable().optional(),
+  estimatedDays: z.number().nullable().optional(),
+  zoneCode: z.string().nullable().optional(),
+  locationId: z.string().nullable().optional(),
+  pickupPointId: z.string().nullable().optional(),
+  scheduledDate: z.string().nullable().optional(),
+  scheduledTime: z.string().nullable().optional(),
+  data: z.record(z.unknown()).optional().default({})
+});
+var OrderDraftSchema = z.object({
+  id: z.string(),
+  storeId: z.string().optional(),
+  customerId: z.coerce.string().nullable().optional(),
+  cartId: z.string().nullable().optional(),
+  draftNumber: z.string(),
+  currencyCode: z.string().optional().default("PEN"),
+  source: z.string().nullable().optional(),
+  notes: z.string().nullable().optional(),
+  email: z.string().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  firstName: z.string().nullable().optional(),
+  lastName: z.string().nullable().optional(),
+  identificationType: z.string().nullable().optional(),
+  identificationNumber: z.string().nullable().optional(),
+  entityTaxId: z.string().nullable().optional(),
+  entityName: z.string().nullable().optional(),
+  status: z.string(),
+  draftDate: z.string().nullable().optional(),
+  sentAt: z.string().nullable().optional(),
+  viewedAt: z.string().nullable().optional(),
+  acceptedAt: z.string().nullable().optional(),
+  rejectedAt: z.string().nullable().optional(),
+  expiredAt: z.string().nullable().optional(),
+  cancelledAt: z.string().nullable().optional(),
+  convertedAt: z.string().nullable().optional(),
+  shareToken: z.string().nullable().optional(),
+  shareExpiresAt: z.string().nullable().optional(),
+  allowAnonymousShareAccess: z.boolean().optional().default(false),
+  sharedAt: z.string().nullable().optional(),
+  billingAddress: StorefrontOrderAddressSchema.optional().nullable(),
+  shippingAddress: StorefrontOrderAddressSchema.optional().nullable(),
+  metadata: z.record(z.unknown()).optional().default({}),
+  subTotal: z.number().optional().default(0),
+  discount: z.number().optional().default(0),
+  shipping: z.number().optional().default(0),
+  tax: z.number().optional().default(0),
+  warranty: z.number().optional().default(0),
+  total: z.number().optional().default(0),
+  paymentMethod: z.string().optional().default(""),
+  paymentCode: z.string().optional().default(""),
+  items: z.array(OrderDraftItemSchema).optional().default([]),
+  shippingMethods: z.array(OrderDraftShippingMethodSchema).optional().default([]),
+  createdOn: z.string().optional(),
+  updatedOn: z.string().nullable().optional()
+});
+
+// src/core/client/store-api-order-draft.service.ts
+async function getSharedOrderDraft(shareToken) {
+  const client = await getStoreApiClient();
+  const response = await client.get(
+    `order-drafts/share/${encodeURIComponent(shareToken)}`,
+    { noStore: true }
+  );
+  return OrderDraftSchema.parse(response);
+}
+var defaultOptions = {
+  queries: {
+    staleTime: 60 * 1e3
+  }
+};
+function QueryProvider({ children, dehydratedState }) {
+  const queryClientRef = useRef(null);
+  const hydratedRef = useRef(false);
+  if (queryClientRef.current === null) {
+    queryClientRef.current = new QueryClient({ defaultOptions });
+  }
+  const queryClient = queryClientRef.current;
+  useEffect(() => {
+    if (dehydratedState && !hydratedRef.current) {
+      hydrate(queryClient, dehydratedState);
+      hydratedRef.current = true;
+    }
+  }, [queryClient, dehydratedState]);
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children });
+}
+var StorefrontAuthContext = createContext(null);
+function StorefrontAuthProvider({
+  authClient,
+  children
+}) {
+  return /* @__PURE__ */ jsx(StorefrontAuthContext.Provider, { value: authClient, children });
+}
+function useStorefrontAuthClient() {
+  const client = useContext(StorefrontAuthContext);
+  if (!client) {
+    throw new Error(
+      "useStorefrontAuthClient debe usarse dentro de StorefrontAuthProvider (o EcomiqProvider con authClient)."
+    );
+  }
+  return client;
+}
+function storefrontSessionEndsSoon(expiresAt, skewMs = 12e4) {
+  if (!expiresAt) return false;
+  return Date.now() + skewMs >= expiresAt.getTime();
+}
+var storefrontAccessTokenNeedsRefresh = storefrontSessionEndsSoon;
+function parseStorefrontSessionExpires(at) {
+  if (!at) return void 0;
+  if (at instanceof Date) return Number.isNaN(at.getTime()) ? void 0 : at;
+  if (typeof at === "string") {
+    const d = new Date(at);
+    return Number.isNaN(d.getTime()) ? void 0 : d;
+  }
+  return void 0;
+}
+function mapSessionUser(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const u = raw;
+  const explicitFirst = typeof u.firstName === "string" ? u.firstName : typeof u.given_name === "string" ? u.given_name : "";
+  const explicitLast = typeof u.lastName === "string" ? u.lastName : typeof u.family_name === "string" ? u.family_name : "";
+  if (explicitFirst || explicitLast) {
+    return {
+      id: String(u.id ?? ""),
+      email: String(u.email ?? ""),
+      firstName: explicitFirst,
+      lastName: explicitLast,
+      name: typeof u.name === "string" ? u.name : void 0,
+      phone: typeof u.phone === "string" ? u.phone : void 0
+    };
+  }
+  const emailLocal = String(u.email ?? "").split("@")[0] ?? "";
+  const full = typeof u.name === "string" ? u.name.trim() : emailLocal.trim();
+  const parts = full ? full.split(/\s+/) : [];
+  return {
+    id: String(u.id ?? ""),
+    email: String(u.email ?? ""),
+    firstName: parts[0] ?? "",
+    lastName: parts.slice(1).join(" "),
+    name: typeof u.name === "string" ? u.name : void 0,
+    phone: typeof u.phone === "string" ? u.phone : void 0
+  };
+}
+function useStorefrontSession() {
+  const authClient = useStorefrontAuthClient();
+  const session = authClient.useSession();
+  const user = mapSessionUser(session.data?.user);
+  const storefrontSession = session.data?.session;
+  const sessionExpiresAt = parseStorefrontSessionExpires(storefrontSession?.expiresAt);
+  return {
+    session,
+    user,
+    sessionExpiresAt,
+    isAuthenticated: Boolean(session.data?.user),
+    isPending: session.isPending,
+    error: session.error,
+    refetch: session.refetch,
+    signOut: () => authClient.signOut()
+  };
+}
+function useStoreProducts() {
+  const useStorefrontProductsList = (params) => {
+    return useQuery({
+      queryKey: ["storefront", "products", params],
+      queryFn: () => getStorefrontProducts(params)
+    });
+  };
+  const useStorefrontInfiniteProducts = (params) => {
+    return useInfiniteQuery({
+      queryKey: ["storefront", "products", "infinite", params],
+      queryFn: ({ pageParam = 1 }) => getStorefrontProducts({ ...params, page: pageParam }),
+      getNextPageParam: (lastPage) => lastPage.pageIndex < lastPage.totalPages ? lastPage.pageIndex + 1 : void 0,
+      initialPageParam: 1
+    });
+  };
+  const useProductBySlug = (slug) => {
+    return useQuery({
+      queryKey: ["storefront", "product", "slug", slug],
+      queryFn: () => getStorefrontProductBySlug(slug),
+      enabled: !!slug
+    });
+  };
+  const useRefreshStorefrontProducts = () => {
+    const queryClient = useQueryClient();
+    return useMutation({
+      mutationFn: (params) => getStorefrontProducts(params),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["storefront", "products"] });
+      }
+    });
+  };
+  return {
+    useStorefrontProductsList,
+    useStorefrontInfiniteProducts,
+    useProductBySlug,
+    useRefreshStorefrontProducts
+  };
+}
+function useStoreCollections() {
+  const useStorefrontCollectionsList = () => {
+    return useQuery({
+      queryKey: ["storefront", "collections"],
+      queryFn: () => getStorefrontCollections()
+    });
+  };
+  const useCollectionBySlug = (slug) => {
+    return useQuery({
+      queryKey: ["storefront", "collection", "slug", slug],
+      queryFn: () => getStorefrontCollectionBySlug(slug),
+      enabled: !!slug
+    });
+  };
+  const useRefreshStorefrontCollections = () => {
+    const queryClient = useQueryClient();
+    return useMutation({
+      mutationFn: () => getStorefrontCollections(),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["storefront", "collections"] });
+      }
+    });
+  };
+  return {
+    useStorefrontCollectionsList,
+    useCollectionBySlug,
+    useRefreshStorefrontCollections
+  };
+}
+function useStorePages() {
+  const useStorefrontPagesList = () => {
+    return useQuery({
+      queryKey: ["storefront", "pages"],
+      queryFn: () => getStorefrontPages()
+    });
+  };
+  const usePageBySlug = (slug) => {
+    return useQuery({
+      queryKey: ["storefront", "page", "slug", slug],
+      queryFn: () => getStorefrontPageBySlug(slug),
+      enabled: !!slug
+    });
+  };
+  const useRefreshStorefrontPages = () => {
+    const queryClient = useQueryClient();
+    return useMutation({
+      mutationFn: () => getStorefrontPages(),
+      onSuccess: () => {
+        queryClient.invalidateQueries({ queryKey: ["storefront", "pages"] });
+      }
+    });
+  };
+  return {
+    useStorefrontPagesList,
+    usePageBySlug,
+    useRefreshStorefrontPages
+  };
+}
+var useCart = create()(
+  persist(
+    (set) => ({
+      count: 0,
+      cart: [],
+      cartTokenId: null,
+      setCartTokenId: (token) => set((state) => ({ ...state, cartTokenId: token })),
+      checkoutStep: null,
+      setCheckoutStep: (step) => set((state) => ({ ...state, checkoutStep: step })),
+      checkoutCustomerLocal: null,
+      setCheckoutCustomerLocal: (customer) => set((state) => {
+        if (!state.cartTokenId) return state;
+        return {
+          checkoutCustomerLocal: {
+            cartTokenId: state.cartTokenId,
+            customer
+          }
+        };
+      }),
+      clearCheckoutCustomerLocal: () => set(() => ({ checkoutCustomerLocal: null })),
+      addCart: (item) => set((state) => {
+        const existingItem = state.cart.find(
+          (cartItem) => cartItem.id === item.id
+        );
+        if (existingItem) {
+          const newQuantity = Math.max(0, existingItem.quantity) + 1;
+          const cart2 = state.cart.map(
+            (cartItem) => cartItem.id === item.id ? { ...cartItem, quantity: newQuantity } : cartItem
+          );
+          const count2 = cart2.reduce((sum, i) => sum + Math.max(0, i.quantity), 0);
+          return { count: count2, cart: cart2 };
+        }
+        const newItem = {
+          ...item,
+          quantity: Math.max(1, Math.max(0, item.quantity ?? 1))
+        };
+        const cart = [...state.cart, newItem];
+        const count = cart.reduce((sum, i) => sum + Math.max(0, i.quantity), 0);
+        return { count, cart };
+      }),
+      removeCart: (id) => set((state) => {
+        const existingItem = state.cart.find((item) => item.id === id);
+        if (!existingItem) return state;
+        if (existingItem.quantity > 1) {
+          const newQuantity = Math.max(0, existingItem.quantity - 1);
+          const cart2 = state.cart.map(
+            (cartItem) => cartItem.id === id ? { ...cartItem, quantity: newQuantity } : cartItem
+          );
+          const count2 = cart2.reduce((sum, i) => sum + Math.max(0, i.quantity), 0);
+          return { count: count2, cart: cart2 };
+        }
+        const cart = state.cart.filter((item) => item.id !== id);
+        const count = Math.max(0, cart.reduce((sum, i) => sum + Math.max(0, i.quantity), 0));
+        return { count, cart };
+      }),
+      clearCartSession: () => set(() => ({
+        count: 0,
+        cart: [],
+        cartTokenId: null,
+        checkoutStep: null,
+        checkoutCustomerLocal: null
+      }))
+    }),
+    { name: "cart-storage" }
+  )
+);
+
+// src/react/shell/hooks/use-store-cart.ts
+function useStoreCart() {
+  const useGetCart = (cartId) => useQuery({
+    queryKey: ["storefront", "cart", cartId ?? null],
+    queryFn: () => getCart(cartId ?? void 0),
+    // Si devuelve 404 no reintentar; para otros errores solo un intento adicional como máximo.
+    retry: (failureCount, error) => {
+      const status = error.status;
+      if (status === 404) return false;
+      return failureCount < 1;
+    },
+    // Evitar refetch automático al enfocar la ventana; el carrito se carga una sola vez aquí.
+    refetchOnWindowFocus: false,
+    enabled: !!cartId
+  });
+  const useCreateCart = () => useMutation({
+    mutationFn: (data) => createCart(data)
+  });
+  const useUpdateCartBuyer = () => useMutation({
+    mutationFn: ({ data, cartId }) => patchCartBuyer(data, cartId)
+  });
+  const useUpdateCartAddresses = () => useMutation({
+    mutationFn: ({ data, cartId }) => patchCartAddresses(data, cartId)
+  });
+  const useAddCartItem = () => useMutation({
+    mutationFn: ({ cartId, ...data }) => addCartItem(data, cartId)
+  });
+  const useCheckoutCart = () => useMutation({
+    mutationFn: ({ data, cartId }) => checkoutCart(data, cartId)
+  });
+  const useUploadPaymentReceipt = () => useMutation({
+    mutationFn: ({ cartId, file }) => uploadPaymentReceipt(cartId, file)
+  });
+  const useGetCartCheckout = (cartId) => {
+    const inactiveHandledRef = useRef(null);
+    const query = useQuery({
+      queryKey: ["storefront", "cart", cartId ?? null, "checkout"],
+      queryFn: () => getCartCheckout(cartId),
+      retry: (failureCount, error) => {
+        const status = error.status;
+        if (status === 404) return false;
+        if (status === 400 && isCartNotActiveApiError(error)) return false;
+        return failureCount < 1;
+      },
+      /** Evita GET repetidos al cambiar de paso / re-render; `refetch()` sigue forzando actualización tras mutaciones. */
+      staleTime: 6e4,
+      refetchOnMount: false,
+      refetchOnReconnect: false,
+      refetchOnWindowFocus: false,
+      enabled: !!cartId
+    });
+    useEffect(() => {
+      inactiveHandledRef.current = null;
+    }, [cartId]);
+    useEffect(() => {
+      if (!cartId) return;
+      if (!query.isError || !query.error) return;
+      if (!isCartNotActiveApiError(query.error)) return;
+      if (inactiveHandledRef.current === cartId) return;
+      inactiveHandledRef.current = cartId;
+      toast.error(
+        "Este carrito ya no est\xE1 disponible. Se ha vaciado tu bolsa para que puedas empezar de nuevo."
+      );
+      useCart.getState().clearCartSession();
+    }, [cartId, query.isError, query.error]);
+    return query;
+  };
+  const useGetCartPaymentMethods = (cartId) => useQuery({
+    queryKey: ["storefront", "cart", cartId ?? null, "payment-methods"],
+    queryFn: () => getCartPaymentMethods(cartId ?? void 0),
+    retry: (failureCount, error) => {
+      const status = error.status;
+      if (status === 404) return false;
+      return failureCount < 1;
+    },
+    refetchOnWindowFocus: false,
+    enabled: !!cartId
+  });
+  const useGetShippingOptions = (cartId, postalCode, enabled) => useQuery({
+    queryKey: [
+      "storefront",
+      "cart",
+      cartId ?? null,
+      "shipping-options",
+      postalCode ?? ""
+    ],
+    queryFn: () => getShippingOptions(cartId, postalCode),
+    retry: (failureCount, error) => {
+      const status = error.status;
+      if (status === 404) return false;
+      return failureCount < 1;
+    },
+    refetchOnWindowFocus: false,
+    enabled: !!cartId && !!postalCode?.trim() && enabled
+  });
+  const usePutCartShippingMethod = () => useMutation({
+    mutationFn: ({ cartId, data }) => putCartShippingMethod(cartId, data)
+  });
+  const useAddCartCoupon = () => useMutation({
+    mutationFn: ({ cartId, data }) => addCartCoupon(cartId, data)
+  });
+  const useRemoveCartCoupon = () => useMutation({
+    mutationFn: ({ cartId, code }) => removeCartCoupon(cartId, code)
+  });
+  return {
+    useCreateCart,
+    useGetCart,
+    useGetCartCheckout,
+    useUpdateCartBuyer,
+    useUpdateCartAddresses,
+    useAddCartItem,
+    useCheckoutCart,
+    useUploadPaymentReceipt,
+    useGetCartPaymentMethods,
+    useGetShippingOptions,
+    usePutCartShippingMethod,
+    useAddCartCoupon,
+    useRemoveCartCoupon
+  };
+}
+var useStore = create()(
+  (set) => ({
+    data: null,
+    drawers: {
+      cart: false,
+      search: false,
+      menu: false,
+      filter: false
+    },
+    openDrawer: (drawer) => set((state) => ({
+      drawers: {
+        ...state.drawers,
+        [drawer]: true
+      }
+    })),
+    closeDrawer: (drawer) => set((state) => ({
+      drawers: {
+        ...state.drawers,
+        [drawer]: false
+      }
+    })),
+    toggleDrawer: (drawer) => set((state) => ({
+      drawers: {
+        ...state.drawers,
+        [drawer]: !state.drawers[drawer]
+      }
+    })),
+    closeAllDrawers: () => set((state) => ({
+      drawers: Object.keys(state.drawers).reduce(
+        (acc, key) => ({ ...acc, [key]: false }),
+        {}
+      )
+    })),
+    modals: {
+      login: false,
+      signup: false
+    },
+    openModal: (modal) => set((state) => ({
+      modals: {
+        ...state.modals,
+        login: false,
+        signup: false,
+        [modal]: true
+      }
+    })),
+    closeModal: (modal) => set((state) => ({
+      modals: {
+        ...state.modals,
+        login: false,
+        signup: false,
+        [modal]: false
+      }
+    })),
+    toggleModal: (modal) => set((state) => ({
+      modals: {
+        ...state.modals,
+        [modal]: !state.modals[modal]
+      }
+    })),
+    closeAllModals: () => set((state) => ({
+      modals: Object.keys(state.modals).reduce(
+        (acc, key) => ({ ...acc, [key]: false }),
+        {}
+      )
+    }))
+  })
+);
+function EcomiqProvider({
+  store,
+  authClient,
+  children,
+  withShellUi = false
+}) {
+  useStore.setState({ data: store ?? null });
+  useEffect(() => {
+    setClientStoreId(store?.store.id ?? null);
+    return () => setClientStoreId(null);
+  }, [store]);
+  const [queryClient] = useState(() => new QueryClient());
+  const tree = /* @__PURE__ */ jsxs(QueryClientProvider, { client: queryClient, children: [
+    children,
+    withShellUi ? /* @__PURE__ */ jsx(EcomiqShellUi, {}) : null
+  ] });
+  if (!authClient) return tree;
+  return /* @__PURE__ */ jsx(StorefrontAuthProvider, { authClient, children: tree });
+}
+function EcomiqShellUi() {
+  const [ui, setUi] = useState(null);
+  useEffect(() => {
+    void import('../ecomiq-shell-ui-SWIFLQVM.js').then((mod) => setUi(() => mod.EcomiqShellUi));
+  }, []);
+  return ui ? React2.createElement(ui) : null;
+}
+
+// src/react/auth/ecomiq-oauth-password-constants.ts
+var PLUGIN_ID = "ecomiq-oauth-password";
+
+// src/react/auth/ecomiq-oauth-password-client.ts
+function ecomiqOAuthPasswordClient() {
+  return {
+    id: PLUGIN_ID,
+    pathMethods: {
+      "/ecomiq-oauth/sign-in": "POST"
+    },
+    atomListeners: [
+      {
+        matcher: (path) => path === "/ecomiq-oauth/sign-in",
+        signal: "$sessionSignal"
+      }
+    ]
+  };
+}
+var StorefrontCheckoutSettingsSchema = z.object({
+  allowGuestCheckout: z.boolean().optional(),
+  identityScope: z.enum(["store", "tenant", "global"]).optional(),
+  signInMethods: z.array(z.string()).optional()
+});
+var looseRecord = z.record(z.string(), z.unknown());
+var StorefrontThemeConfigSchema = z.object({
+  name: z.string().nullable().optional(),
+  mode: z.string().nullable().optional(),
+  colors: looseRecord.optional(),
+  fonts: looseRecord.optional(),
+  assets: looseRecord.optional()
+}).passthrough();
+var StorefrontFeaturesEnabledSchema = z.object({
+  flags: looseRecord.optional()
+}).passthrough();
+var StorefrontCmsBrandingSchema = z.object({
+  logoUrl: z.string().nullable().optional(),
+  logoDarkUrl: z.string().nullable().optional(),
+  faviconUrl: z.string().nullable().optional(),
+  socialImageUrl: z.string().nullable().optional()
+});
+var StorefrontCmsSeoSchema = z.object({
+  siteName: z.string().nullable().optional(),
+  metaTitle: z.string().nullable().optional(),
+  metaDescription: z.string().nullable().optional(),
+  titleTemplate: z.string().nullable().optional(),
+  robotsIndex: z.boolean().optional()
+});
+var StorefrontCmsSocialLinksSchema = z.object({
+  instagram: z.string().nullable().optional(),
+  facebook: z.string().nullable().optional(),
+  tiktok: z.string().nullable().optional(),
+  youtube: z.string().nullable().optional(),
+  x: z.string().nullable().optional()
+});
+var StorefrontCmsContactSchema = z.object({
+  supportEmail: z.string().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  whatsapp: z.string().nullable().optional(),
+  address: z.string().nullable().optional(),
+  socialLinks: StorefrontCmsSocialLinksSchema.optional()
+});
+var StorefrontCmsTrackingSchema = z.object({
+  googleAnalyticsMeasurementId: z.string().nullable().optional(),
+  metaPixelId: z.string().nullable().optional(),
+  googleTagManagerContainerId: z.string().nullable().optional()
+});
+var StorefrontCmsCustomScriptsSchema = z.object({
+  enabled: z.boolean().optional(),
+  head: z.string().nullable().optional(),
+  bodyEnd: z.string().nullable().optional()
+});
+var StorefrontCmsSettingsSchema = z.object({
+  themeKey: z.string().optional(),
+  branding: StorefrontCmsBrandingSchema.optional(),
+  seo: StorefrontCmsSeoSchema.optional(),
+  contact: StorefrontCmsContactSchema.optional(),
+  tracking: StorefrontCmsTrackingSchema.optional(),
+  customScripts: StorefrontCmsCustomScriptsSchema.optional(),
+  updatedOn: z.string().nullable().optional()
+});
+var StorefrontCmsPageSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  layout: z.string().optional(),
+  version: z.number().optional(),
+  settings: z.record(z.string(), z.unknown()).optional().nullable(),
+  sections: z.array(z.unknown()).optional(),
+  status: z.string().optional(),
+  hasPublishedVersion: z.boolean().optional(),
+  publishedOn: z.string().nullable().optional(),
+  publishedBy: z.string().nullable().optional(),
+  createdOn: z.string().nullable().optional(),
+  updatedOn: z.string().nullable().optional(),
+  createdBy: z.string().nullable().optional(),
+  updatedBy: z.string().nullable().optional(),
+  lastModifiedBy: z.string().nullable().optional()
+}).passthrough();
+var StorefrontSettingsLegacyFlatSchema = z.object({
+  id: z.coerce.string(),
+  tenantId: z.string().nullable().optional(),
+  name: z.string(),
+  slug: z.coerce.string().optional(),
+  description: z.string().nullable().optional(),
+  visibility: z.string().nullable().optional(),
+  logo: z.string().nullable().optional(),
+  favicon: z.string().nullable().optional(),
+  icon: z.string().nullable().optional(),
+  currency: z.string().nullable().optional(),
+  language: z.string().nullable().optional(),
+  themeConfig: z.unknown().optional().nullable(),
+  featuresEnabled: z.unknown().optional().nullable(),
+  checkoutSettings: StorefrontCheckoutSettingsSchema.optional().nullable()
+}).passthrough();
+function unwrapSettingsResponseBody(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return v;
+  const o = v;
+  if ("data" in o && o.data != null && typeof o.data === "object" && !Array.isArray(o.data)) {
+    return o.data;
+  }
+  return v;
+}
+function isLegacyFlatSettingsPayload(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return false;
+  const o = v;
+  if ("store" in o || "schemaVersion" in o || "cms" in o) return false;
+  return (typeof o.id === "string" || typeof o.id === "number") && typeof o.name === "string";
+}
+function normalizeStorefrontSettingsPayload(v) {
+  const body = unwrapSettingsResponseBody(v);
+  if (!isLegacyFlatSettingsPayload(body)) return body;
+  const raw = body;
+  const parsed = StorefrontSettingsLegacyFlatSchema.safeParse(raw);
+  if (!parsed.success) return body;
+  const l = parsed.data;
+  const currency = l.currency?.trim() ? l.currency : "PEN";
+  const language = l.language?.trim() ? l.language : "es";
+  const slug = l.slug?.trim() ? l.slug : l.id;
+  return {
+    schemaVersion: 0,
+    generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+    store: {
+      id: l.id,
+      tenantId: l.tenantId ?? void 0,
+      name: l.name,
+      slug,
+      description: l.description ?? null,
+      logo: l.logo ?? null,
+      icon: l.icon ?? null,
+      visibility: l.visibility ?? void 0,
+      currency,
+      language,
+      themeConfig: l.themeConfig ?? void 0,
+      featuresEnabled: l.featuresEnabled ?? void 0,
+      checkoutSettings: l.checkoutSettings ?? void 0
+    },
+    cms: {
+      settings: {
+        branding: {
+          faviconUrl: l.favicon ?? null,
+          logoUrl: l.logo ?? null,
+          logoDarkUrl: null,
+          socialImageUrl: null
+        }
+      },
+      pages: []
+    }
+  };
+}
+var StorefrontStoreSchema = z.object({
+  id: z.string(),
+  tenantId: z.string().optional(),
+  sellerId: z.string().optional(),
+  plan: z.string().optional(),
+  storageLimitBytes: z.number().optional(),
+  monthlyTransferLimitBytes: z.number().optional(),
+  maxUploadSizeBytes: z.number().optional(),
+  maxStores: z.number().optional(),
+  maxMembers: z.number().optional(),
+  maxProducts: z.number().optional(),
+  maxCategories: z.number().optional(),
+  maxBrands: z.number().optional(),
+  maxAttributes: z.number().optional(),
+  maxCollections: z.number().optional(),
+  enableApi: z.boolean().optional(),
+  isActive: z.boolean().optional(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  avatarUrl: z.string().nullable().optional(),
+  logo: z.string().nullable().optional(),
+  icon: z.string().nullable().optional(),
+  slug: z.string(),
+  domain: z.string().nullable().optional(),
+  domains: z.array(z.string()).optional(),
+  timeZone: z.string().nullable().optional(),
+  currency: z.string(),
+  language: z.string(),
+  visibility: z.string().optional(),
+  privateAccessHash: z.string().nullable().optional(),
+  privateAccessVersion: z.number().optional(),
+  themeConfig: StorefrontThemeConfigSchema.optional(),
+  featuresEnabled: StorefrontFeaturesEnabledSchema.optional(),
+  checkoutSettings: StorefrontCheckoutSettingsSchema.optional().nullable()
+}).passthrough();
+var StorefrontSettingsEnvelopeSchema = z.object({
+  schemaVersion: z.number(),
+  generatedAt: z.string(),
+  store: StorefrontStoreSchema,
+  cms: z.object({
+    settings: StorefrontCmsSettingsSchema,
+    pages: z.array(StorefrontCmsPageSchema)
+  })
+}).passthrough();
+var StorefrontSettingsSchema = z.preprocess(
+  normalizeStorefrontSettingsPayload,
+  StorefrontSettingsEnvelopeSchema
+);
+function storefrontStoreRecord(settings) {
+  return settings?.store ?? null;
+}
+
+// src/core/lib/ecomiq-oauth-identity.ts
+function buildEcomiqOAuthIdentityHeaders(settings) {
+  const record = storefrontStoreRecord(settings);
+  if (!record?.id) {
+    throw new Error("Tienda no disponible para iniciar sesi\xF3n");
+  }
+  const checkout = record.checkoutSettings;
+  const identityScope = checkout?.identityScope === "tenant" ? "tenant" : "store";
+  const headers = {
+    "x-Identity-Scope": identityScope,
+    "x-Store-Id": record.id
+  };
+  if (record.tenantId) headers["x-Tenant-Id"] = record.tenantId;
+  return headers;
+}
+
+// src/react/auth/ecomiq-storefront-sign-in.ts
+async function signInWithEcomiqCredentials(authClient, settings, credentials) {
+  const response = await authClient.$fetch("/ecomiq-oauth/sign-in", {
+    method: "POST",
+    headers: buildEcomiqOAuthIdentityHeaders(settings),
+    body: credentials
+  });
+  if (response.error) {
+    throw new Error(response.error.message ?? "Error al iniciar sesi\xF3n");
+  }
+  return response;
+}
+
+// src/react/shell/lib/find-storefront-cms-page.ts
+function isRenderableCmsPage(p) {
+  if (!p.status) return true;
+  return p.status === "published";
+}
+function findStorefrontCmsPageBySlug(settings, slug) {
+  const pages = settings?.cms?.pages;
+  if (!pages?.length) return null;
+  const raw = pages.find(
+    (p) => p.slug === slug && isRenderableCmsPage(p)
+  );
+  if (!raw) return null;
+  const parsed = StorefrontPageDetailSchema.safeParse(raw);
+  return parsed.success ? parsed.data : null;
+}
+
+// src/core/constants/currency.ts
+var countryCurrency = {
+  "PEN": "es-PE",
+  "USD": "en-US",
+  "COP": "es-CO",
+  "MXN": "es-MX"
+};
+
+// src/core/utils/format-currency.ts
+function formatCurrency(amount, currency = "USD") {
+  const locale = countryCurrency[currency] ?? "en-US";
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency
+  }).format(amount);
+}
+function buildOptionGroups(variants) {
+  const map = /* @__PURE__ */ new Map();
+  for (const v of variants) {
+    for (const opt of v.options ?? []) {
+      const key = opt.key;
+      const name = opt.name ?? key;
+      if (!map.has(key)) map.set(key, /* @__PURE__ */ new Map());
+      map.get(key).set(opt.value, name);
+    }
+  }
+  return Array.from(map.entries()).map(([key, valueMap]) => ({
+    key,
+    name: Array.from(valueMap.values())[0] ?? key,
+    values: Array.from(valueMap.keys())
+  }));
+}
+function findVariant(variants, selected, hasConfigurableOptions) {
+  if (!hasConfigurableOptions && variants.length > 0) {
+    return variants[0] ?? null;
+  }
+  if (Object.keys(selected).length === 0) return null;
+  for (const v of variants) {
+    const opts = v.options ?? [];
+    const match = opts.length > 0 && opts.every((o) => selected[o.key] === o.value);
+    if (match) return v;
+  }
+  return null;
+}
+function getInitialOptions(variants, optionGroups) {
+  const first = variants[0];
+  if (!first) return {};
+  const opts = first.options ?? [];
+  const selected = {};
+  for (const g of optionGroups) {
+    const o = opts.find((x) => x.key === g.key);
+    if (o) selected[g.key] = o.value;
+  }
+  return selected;
+}
+function ProductVariantSelector({
+  product,
+  currency = "USD",
+  features = [],
+  onVariantChange,
+  children
+}) {
+  const variants = useMemo(() => product.variants ?? [], [product.variants]);
+  const optionGroups = useMemo(() => buildOptionGroups(variants), [variants]);
+  const hasConfigurableOptions = optionGroups.length > 0;
+  const [selectedOptions, setSelectedOptions] = useState(
+    () => getInitialOptions(variants, optionGroups)
+  );
+  const selectedVariant = useMemo(
+    () => findVariant(variants, selectedOptions, hasConfigurableOptions),
+    [variants, selectedOptions, hasConfigurableOptions]
+  );
+  const displayPrice = selectedVariant?.price ?? product.price ?? 0;
+  const compareAtPrice = selectedVariant?.compareAtPrice ?? product.compareAtPrice;
+  const isAvailable = (selectedVariant ? (selectedVariant.quantity ?? 0) > 0 : product.isAvailable) ?? true;
+  useEffect(() => {
+    onVariantChange?.(selectedVariant, displayPrice);
+  }, [selectedVariant, displayPrice, onVariantChange]);
+  const setOption = useCallback((key, value) => {
+    setSelectedOptions((prev) => ({ ...prev, [key]: value }));
+  }, []);
+  const hasVariants = hasConfigurableOptions;
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-5", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-2 flex-wrap", children: [
+      /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: "inline-flex items-center rounded-md bg-primary/10 px-2.5 py-0.5 text-base font-semibold text-primary",
+          "data-testid": "product-display-price",
+          children: formatCurrency(displayPrice, currency)
+        }
+      ),
+      compareAtPrice != null && compareAtPrice > displayPrice && /* @__PURE__ */ jsx("span", { className: "text-sm text-muted-foreground line-through", children: formatCurrency(compareAtPrice, currency) })
+    ] }),
+    hasVariants && optionGroups.map((group) => /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsx("span", { className: "text-xs font-semibold uppercase tracking-wider text-muted-foreground", children: group.name }),
+      /* @__PURE__ */ jsx("div", { className: "flex flex-wrap gap-2", children: group.values.map((value) => {
+        const isSelected = selectedOptions[group.key] === value;
+        const isColorLike = group.key.toLowerCase().includes("color") || group.key.toLowerCase().includes("colour");
+        return /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => setOption(group.key, value),
+            className: isColorLike ? `min-w-[72px] rounded-md border-2 px-3 py-2 text-sm font-medium transition-colors focus:outline-none focus:ring-2 focus:ring-primary focus:ring-offset-2 ${isSelected ? "border-primary bg-primary text-foreground" : "border-border bg-muted/30 text-foreground hover:border-muted-foreground/50"}` : `rounded-md border px-3 py-2 text-sm font-medium transition-colors focus:outline-none focus:ring-2 focus:ring-primary focus:ring-offset-2 ${isSelected ? "border-primary bg-muted ring-1 ring-primary" : "border-border bg-transparent text-muted-foreground hover:border-muted-foreground/50 hover:text-foreground"}`,
+            style: isColorLike && isSelected && value.toLowerCase() === "black" ? { backgroundColor: "#1a1a1a", borderColor: "#1a1a1a", color: "#fff" } : isColorLike && value.toLowerCase() === "white" ? { backgroundColor: "#fafafa", color: "#1a1a1a", borderColor: "#e5e5e5" } : void 0,
+            "data-testid": `variant-option-${group.key}-${value}`,
+            children: value
+          },
+          value
+        );
+      }) })
+    ] }, group.key)),
+    features.length > 0 && /* @__PURE__ */ jsx("ul", { className: "list-disc list-inside space-y-1 text-sm text-muted-foreground", children: features.map((f, i) => /* @__PURE__ */ jsx("li", { children: f }, i)) }),
+    children?.({
+      product,
+      selectedVariant,
+      displayPrice,
+      compareAtPrice,
+      isAvailable,
+      selectedOptions
+    })
+  ] });
+}
+
+// src/npm/framework-react-client.ts
+var usePublicStore = () => useStore.getState().data;
+
+export { CustomerAddressSchema, CustomerAddressUpsertSchema, CustomerMeSchema, CustomerOrderDetailSchema, CustomerOrderListItemSchema, CustomerProfilePatchSchema, CustomerRegisterRequestSchema, EcomiqProvider, ProductVariantSelector, QueryProvider, StoreApiClient, StorefrontAuthProvider, StorefrontProductSchema, StorefrontProductsResponseSchema, StorefrontSettingsSchema, addCartCoupon, checkoutCart, createCart, createCustomerAddress, createStoreApiClient, customerMeToProfilePatch, deleteCustomerAddress, ecomiqOAuthPasswordClient, findStorefrontCmsPageBySlug, formatCurrency, getCart, getCartCheckout, getCartPaymentMethods, getCustomerAddresses, getCustomerMe, getCustomerOrder, getCustomerOrders, getSharedOrderDraft, getShippingOptions, getStoreApiBaseUrl, getStoreApiClient, getStorefrontCollectionBySlug, getStorefrontCollections, getStorefrontPageBySlug, getStorefrontPagePreview, getStorefrontPages, getStorefrontProductBySlug, getStorefrontProducts, isCartNotActiveApiError, patchCartAddresses, patchCartBuyer, patchCustomer, putCartShippingMethod, registerCustomer, removeCartCoupon, setClientStoreId, setServerRequestOrigin, setServerStoreId, signInWithEcomiqCredentials, storeApiClient, storefrontAccessTokenNeedsRefresh, storefrontSessionEndsSoon, updateCustomerAddress, uploadPaymentReceipt, useCart, usePublicStore, useStore, useStoreCart, useStoreCollections, useStorePages, useStoreProducts, useStorefrontAuthClient, useStorefrontSession };
+//# sourceMappingURL=client.js.map
+//# sourceMappingURL=client.js.map