@ecomiq/storefront 2.1.4 → 3.0.0

package/dist/catalog-hooks.d.ts

@@ -0,0 +1,111 @@
+import { GeoPlace } from "./public-pages.js";
+import { SearchFilter } from "@ecomiq/core";
+export declare const SORT_OPTIONS: readonly [{
+  readonly value: "relevance";
+  readonly label: "Relevancia";
+}, {
+  readonly value: "newest";
+  readonly label: "Más nuevos";
+}, {
+  readonly value: "price_asc";
+  readonly label: "Precio: menor a mayor";
+}, {
+  readonly value: "price_desc";
+  readonly label: "Precio: mayor a menor";
+}, {
+  readonly value: "name_asc";
+  readonly label: "Nombre: A–Z";
+}];
+export type PageItem = number | "gap";
+export type SortValue = (typeof SORT_OPTIONS)[number]["value"];
+export type SortLabels = Partial<Record<SortValue, string>>;
+export type FilterLabels = {
+  filters?: Map<string, string>;
+  values?: Map<string, string>;
+};
+type FilterTranslate = (source: string, values?: Readonly<Record<string, string>>) => string;
+export type FilterChipText = {
+  labels?: FilterLabels;
+  price?: (amount: string) => string;
+  translate?: FilterTranslate;
+};
+export declare function filterLabel(filter: SearchFilter, labels?: FilterLabels, translate?: FilterTranslate): string;
+export declare function filterValueLabel(value: string, label: string | null | undefined, labels?: FilterLabels, translate?: FilterTranslate): string;
+export declare function isSingleChoiceFilter(filter: SearchFilter): boolean;
+export declare function selectedFacetCount(filters: SearchFilter[]): number;
+export declare function activeFilterCount(filters: SearchFilter[], params: URLSearchParams): number;
+export declare function clearedFiltersHref(params: URLSearchParams): string;
+export type ActiveFilterChip = {
+  key: string;
+  value: string;
+  text: string;
+  href: string;
+};
+export declare function activeFilterChips(filters: SearchFilter[], params: URLSearchParams, text?: FilterChipText): ActiveFilterChip[];
+export declare function pageItems(page: number, pages: number): PageItem[];
+export declare function useFacets(): {
+  params: URLSearchParams;
+  navigate: (change: (next: URLSearchParams) => void) => void;
+  toggle: (filterId: string, value: string, checked: boolean) => void;
+  choose: (filterId: string, value: string) => void;
+  setPrice: (from: number | undefined, to: number | undefined, low: number, high: number) => void;
+  clearedHref: string;
+};
+export declare function useSort(labels?: SortLabels): {
+  value: string;
+  label: string;
+  options: {
+    value: "name_asc" | "newest" | "price_asc" | "price_desc" | "relevance";
+    label: string;
+  }[];
+  change: (next: string) => void;
+};
+export declare function usePagination(page: number, pages: number): {
+  items: PageItem[];
+  href: (target: number) => string;
+  hasPrevious: boolean;
+  hasNext: boolean;
+};
+export declare function useSearchSuggestions(initial?: string): {
+  q: string;
+  setQ: import("react").Dispatch<import("react").SetStateAction<string>>;
+  trimmed: string;
+  searching: boolean;
+  products: never[] | {
+    id: string;
+    name: string;
+    slug: string;
+    url: string;
+    imageUrl: string;
+  }[];
+  missing: boolean;
+  loading: boolean;
+  loaded: boolean;
+  current: boolean;
+};
+export declare function placeValue(place: GeoPlace | null): string;
+export declare function useGeoCascade(defaults: {
+  country?: string | null;
+  department?: string | null;
+  province?: string | null;
+  district?: string | null;
+}): {
+  country: string;
+  setCountry: (next: string) => void;
+  department: GeoPlace | null;
+  setDepartment: (next: GeoPlace | null) => void;
+  province: GeoPlace | null;
+  setProvince: (next: GeoPlace | null) => void;
+  district: GeoPlace | null;
+  setDistrict: import("react").Dispatch<import("react").SetStateAction<GeoPlace | null>>;
+  setDepartmentValue: (value: string) => void;
+  setProvinceValue: (value: string) => void;
+  setDistrictValue: (value: string) => void;
+  places: {
+    departments: GeoPlace[];
+    provinces: GeoPlace[];
+    districts: GeoPlace[];
+  };
+  structured: boolean;
+};
+export {};

package/dist/catalog.d.ts

@@ -0,0 +1,5 @@
+import { ShouldRevalidateFunctionArgs } from "react-router";
+import { ProductsParamsInput } from "@ecomiq/core";
+/** Menus, customer and cart data do not depend on filters in the current catalog. */
+export declare function shouldRevalidateCatalogRoot(args: ShouldRevalidateFunctionArgs): boolean;
+export declare function readCatalog(url: URL, base?: ProductsParamsInput): ProductsParamsInput;

package/dist/checkout-DVWSXANi.js

@@ -0,0 +1,474 @@
+import { addressDefaults } from "./address-defaults-BqjRhS82.js";
+import { trackingConsented } from "./analytics/config-DJr-GRhs.js";
+import { purchaseCookie } from "./analytics/cookies-pLozllyB.js";
+import { checkoutAnalytics } from "./analytics/events-Dt81tIp1.js";
+import { cartCookie, cartToken } from "./cart-D7DxZ2lD.js";
+import { optional, text } from "./form-BtQcbXlJ.js";
+import { identityDocumentError, isIdentityDocumentType } from "./documents-T1mzc_j8.js";
+import { CHECKOUT_INTENTS, isIntent } from "./form-contracts-BNpHaTGJ.js";
+import { readPlace } from "./place-CmW4hBWY.js";
+import { customer, customerHeaders, requireCustomerRegistration } from "./session-CKvmFJyg.js";
+import { readCountries, readDocumentCountries, store } from "./store-8Q-_LFrQ.js";
+import { data, redirect, replace } from "react-router";
+import { ApiError, OrderPaymentStartSchema, StorefrontInvoiceTypeSchema } from "@ecomiq/core";
+import { z } from "zod";
+// src/checkout.ts
+const UNSTRUCTURED_POSTAL_CODE = "00000";
+const CheckoutAuthenticationSchema = z.object({ authentication: z.object({
+	payment: OrderPaymentStartSchema,
+	orderStatusUrl: z.string()
+}) });
+function shouldRevalidateCheckout({ actionResult, defaultShouldRevalidate }) {
+	const result = CheckoutAuthenticationSchema.safeParse(actionResult);
+	if (!result.success) return defaultShouldRevalidate;
+	const payment = result.data.authentication.payment;
+	if (payment.actionKind === "threeDS") return false;
+	if (payment.actionKind === "embedded" && payment.providerId === "stripe") return false;
+	return defaultShouldRevalidate;
+}
+function needsShipping(cart) {
+	return cart.items.some((item) => item.requiresShipping);
+}
+function checkoutProgress(cart) {
+	const contact = [
+		cart.email,
+		cart.firstName,
+		cart.lastName,
+		cart.phone
+	].every((value) => value !== null && value !== "");
+	const delivery = contact && (!needsShipping(cart) || cart.shippingAddress !== null);
+	return {
+		contact,
+		delivery,
+		shipping: delivery && (!needsShipping(cart) || cart.shippingMethods.length > 0)
+	};
+}
+function checkoutStep(cart, edit) {
+	const done = checkoutProgress(cart);
+	if (edit === "contact" || !done.contact) return "contact";
+	if (edit === "delivery" || !done.delivery) return "delivery";
+	if (edit === "shipping" || !done.shipping) return "shipping";
+	return "payment";
+}
+function checkoutAddressDefaults(cart, address, countryCode) {
+	const saved = cart.shippingAddress;
+	if (saved) return {
+		country: countryCode,
+		department: saved.department,
+		province: saved.province,
+		district: saved.district,
+		line: saved.address1,
+		reference: saved.address2,
+		phone: saved.phone
+	};
+	if (address) return {
+		...addressDefaults(address),
+		country: countryCode
+	};
+	return {
+		country: countryCode,
+		phone: cart.phone
+	};
+}
+function defaultPaymentMethod(cart, methods) {
+	return (methods.find((method) => method.code === cart.paymentMethodCode) ?? methods.find((method) => method.isDefault) ?? methods[0])?.code;
+}
+function shippingField(group) {
+	return `rate-${group.sellerId ?? "store"}-${group.shippingProfileId ?? "default"}`;
+}
+function rateValue(rate) {
+	if (rate.rateId) return rate.rateId;
+	return [
+		rate.shippingMethodId,
+		rate.target,
+		rate.targetId ?? "",
+		rate.serviceCode ?? ""
+	].join(":");
+}
+function checkoutShipping(groups) {
+	return groups.map((group) => ({
+		...group,
+		field: shippingField(group),
+		rates: group.rates.map((rate) => ({
+			...rate,
+			value: rateValue(rate)
+		}))
+	}));
+}
+async function shippingOptions(client, cart) {
+	const postalCode = cart.shippingAddress?.postalCode;
+	if (!needsShipping(cart) || !postalCode) return [];
+	const options = await client.getShippingOptions({
+		cartToken: cart.token,
+		postalCode
+	});
+	if (options.groups.some((group) => group.rates.length === 0)) return [];
+	return options.groups;
+}
+async function loadCheckout(request, context) {
+	const token = await cartToken(request);
+	if (token === null) throw redirect("/cart");
+	const client = store(context);
+	const checkout = await client.getCartCheckout({ cartToken: token }).catch(async (error) => {
+		if (error instanceof ApiError && (error.status === 404 || error.code === "Carts.NotActive")) throw redirect("/cart", { headers: { "Set-Cookie": await cartCookie.serialize("", { maxAge: 0 }) } });
+		throw error;
+	});
+	if (checkout.cart.items.length === 0) throw redirect("/cart");
+	const { store: settings } = await client.getSettings();
+	const current = await customer(request, context);
+	if (current) await requireCustomerRegistration(request, context, current);
+	const step = checkoutStep(checkout.cart, new URL(request.url).searchParams.get("edit"));
+	const delivery = needsShipping(checkout.cart);
+	const placed = delivery && checkout.cart.shippingAddress !== null;
+	const [me, addresses, countries, shipping, documentCountries] = await Promise.all([
+		current && step === "contact" ? client.getCustomerMe(customerHeaders(current)) : null,
+		current && delivery && !placed ? client.getCustomerAddresses(customerHeaders(current)) : [],
+		delivery ? readCountries(client) : [],
+		placed ? shippingOptions(client, checkout.cart) : [],
+		readDocumentCountries(client)
+	]);
+	const methods = checkout.paymentMethods.methods.filter((method) => method.isActive).sort((a, b) => a.sortOrder - b.sortOrder);
+	return {
+		countryCode: settings.countryCode,
+		documentCountries,
+		language: settings.language,
+		cart: checkout.cart,
+		methods,
+		bumps: checkout.orderBumps,
+		signedIn: current !== null,
+		me,
+		address: addresses.find((item) => item.isDefault) ?? addresses[0] ?? null,
+		countries,
+		shipping: checkoutShipping(shipping),
+		analytics: checkoutAnalytics(checkout.cart)
+	};
+}
+function failure(message) {
+	return data({
+		error: message,
+		promo: false
+	}, { status: 400 });
+}
+async function saveContact(client, token, form) {
+	let invoiceType;
+	if (form.has("invoiceType")) {
+		const selected = StorefrontInvoiceTypeSchema.safeParse(text(form, "invoiceType"));
+		if (!selected.success) return failure("Elige el comprobante.");
+		invoiceType = selected.data;
+	}
+	const identificationNumber = optional(form, "identificationNumber");
+	const entityTaxId = optional(form, "entityTaxId");
+	const input = {
+		cartToken: token,
+		email: text(form, "email"),
+		firstName: text(form, "firstName"),
+		lastName: text(form, "lastName"),
+		phone: text(form, "phone"),
+		identificationType: identificationNumber === null ? null : optional(form, "identificationType"),
+		identificationNumber,
+		identificationCountryCode: identificationNumber !== null || entityTaxId !== null || invoiceType === "invoice" ? optional(form, "identificationCountryCode") : null,
+		entityTaxId,
+		entityName: optional(form, "entityName"),
+		invoiceType
+	};
+	if (!input.email || !input.firstName || !input.lastName || !input.phone) return failure("Completa tus datos de contacto.");
+	if (invoiceType === "invoice" && (input.entityTaxId === null || identityDocumentError("TaxId", input.identificationCountryCode ?? "", input.entityTaxId) !== null || input.entityName === null)) return failure("Ingresa la identificación fiscal, el país emisor y la razón social para la factura.");
+	if (entityTaxId !== null && identityDocumentError("TaxId", input.identificationCountryCode ?? "", entityTaxId) !== null) return failure("Revisa el documento del comprador.");
+	if (identificationNumber !== null && !(isIdentityDocumentType(input.identificationType) && identityDocumentError(input.identificationType, input.identificationCountryCode ?? "", identificationNumber) === null)) return failure("Revisa el documento del comprador.");
+	await client.patchCartBuyer(input);
+	return redirect("/checkout");
+}
+async function saveDelivery(client, token, form) {
+	const { store: settings } = await client.getSettings();
+	const requestedCountry = text(form, "country");
+	if (requestedCountry !== "" && requestedCountry !== settings.countryCode) return failure("La entrega debe ser dentro del país de la tienda.");
+	const cart = await client.getCart({ cartToken: token });
+	const department = readPlace(text(form, "department"));
+	const province = readPlace(text(form, "province"));
+	const district = readPlace(text(form, "district"));
+	const line = text(form, "line");
+	if (!line || !district.name) return failure("Completa la dirección de entrega.");
+	const structured = department.code !== "" && province.code !== "";
+	let city = district.name;
+	let postalCode = optional(form, "postalCode") ?? UNSTRUCTURED_POSTAL_CODE;
+	if (structured) {
+		city = province.name;
+		postalCode = optional(form, "postalCode") ?? district.code;
+	}
+	const address = {
+		name: `${cart.firstName ?? ""} ${cart.lastName ?? ""}`.trim() || line,
+		address1: line,
+		address2: optional(form, "reference"),
+		city,
+		countryCode: settings.countryCode,
+		department: department.name || null,
+		province: structured ? province.name : null,
+		district: district.name,
+		postalCode,
+		phone: optional(form, "phone") ?? cart.phone,
+		latitude: null,
+		longitude: null
+	};
+	await client.patchCartAddresses({
+		cartToken: token,
+		shippingAddress: {
+			...address,
+			departmentCode: structured ? department.code : null,
+			provinceCode: structured ? province.code : null,
+			districtCode: structured ? district.code : null
+		},
+		billingAddress: address
+	});
+	return redirect("/checkout");
+}
+async function saveShipping(client, token, form) {
+	const postalCode = (await client.getCart({ cartToken: token })).shippingAddress?.postalCode;
+	if (!postalCode) return failure("Primero indica la dirección de entrega.");
+	const { groups } = await client.getShippingOptions({
+		cartToken: token,
+		postalCode
+	});
+	if (groups.length === 0 || groups.some((group) => group.rates.length === 0)) return failure("No hay métodos de envío para esta dirección. Prueba con otra dirección.");
+	const choices = groups.map((group) => ({
+		group,
+		rate: group.rates.find((candidate) => rateValue(candidate) === text(form, shippingField(group)))
+	}));
+	if (choices.some((choice) => choice.rate === void 0)) return failure("Las opciones de envío cambiaron. Elige un método para cada paquete.");
+	for (const { group, rate } of choices) {
+		if (rate === void 0) continue;
+		await client.putCartShippingMethod({
+			cartToken: token,
+			rateId: rate.rateId ?? null,
+			shippingMethodId: rate.shippingMethodId,
+			target: rate.target,
+			targetId: rate.targetId ?? null,
+			serviceCode: rate.serviceCode ?? null,
+			sellerId: group.sellerId ?? null,
+			shippingProfileId: group.shippingProfileId ?? null,
+			scheduledDate: null,
+			scheduledTime: null
+		});
+	}
+	return redirect("/checkout");
+}
+async function savePaymentMethod(client, token, form) {
+	const method = text(form, "method");
+	if (!method) return failure("Elige un medio de pago.");
+	await client.putCartPaymentMethod({
+		cartToken: token,
+		paymentMethodCode: method
+	});
+	return replace("/checkout");
+}
+async function placeOrder(client, input, headers) {
+	try {
+		return await client.checkoutCart(input, headers);
+	} catch (error) {
+		if (error instanceof ApiError && error.status >= 400 && error.status < 500) throw error;
+		if ((await client.getCart({ cartToken: input.cartToken }).catch(() => null))?.status !== "completed") throw error;
+		return client.checkoutCart(input, headers);
+	}
+}
+async function pay(client, token, form, headers, tracked) {
+	const method = text(form, "method");
+	if (!method) return failure("Elige un medio de pago.");
+	if (method === "powerpay") {
+		const identificationNumber = text(form, "payerIdentificationNumber");
+		if (!/^\d{8}$/.test(identificationNumber)) return failure("Ingresa tu DNI de 8 dígitos para pagar con PowerPay.");
+		const cart = await client.getCart({ cartToken: token });
+		const matchingDocument = cart.identificationType === "NationalId" && cart.identificationCountryCode === "PE" && cart.identificationNumber === identificationNumber;
+		if ((cart.identificationType != null || cart.identificationNumber != null) && !matchingDocument || (cart.identificationCountryCode != null || cart.entityTaxId != null) && cart.identificationCountryCode !== "PE") return failure("PowerPay requiere un comprador con DNI peruano. Revisa tus datos o elige otro medio de pago.");
+		if (!matchingDocument) {
+			if (!cart.email || !cart.firstName || !cart.lastName || !cart.phone) return failure("Completa tus datos de contacto.");
+			await client.patchCartBuyer({
+				cartToken: token,
+				email: cart.email,
+				firstName: cart.firstName,
+				lastName: cart.lastName,
+				phone: cart.phone,
+				identificationType: "NationalId",
+				identificationCountryCode: "PE",
+				identificationNumber,
+				invoiceType: cart.invoiceType,
+				entityTaxId: cart.entityTaxId,
+				entityName: cart.entityName
+			});
+		}
+	}
+	const receipt = form.get("receipt");
+	let receiptUrl;
+	if (receipt instanceof File && receipt.size > 0) receiptUrl = (await client.uploadPaymentReceipt({
+		cartToken: token,
+		file: receipt,
+		fileName: receipt.name
+	})).url;
+	const paymentToken = text(form, "token") || void 0;
+	const providerPaymentMethodId = text(form, "providerPaymentMethodId") || void 0;
+	const deviceSessionId = text(form, "deviceSessionId") || void 0;
+	const result = await placeOrder(client, {
+		cartToken: token,
+		paymentMethodCode: method,
+		externalRef: `checkout-${token}`,
+		receiptUrl,
+		token: paymentToken,
+		providerPaymentMethodId,
+		deviceSessionId
+	}, headers);
+	const cookies = new Headers({ "Set-Cookie": await cartCookie.serialize("", { maxAge: 0 }) });
+	if (tracked) cookies.append("Set-Cookie", purchaseCookie(result));
+	if (result.payment?.actionKind === "threeDS") {
+		const payment = result.payment;
+		return data({ authentication: {
+			orderStatusUrl: result.orderStatusUrl,
+			payment: {
+				transactionId: payment.transactionId,
+				externalId: payment.externalId,
+				providerId: payment.providerId ?? null,
+				paymentMethodCode: payment.paymentMethodCode,
+				isCaptured: false,
+				actionKind: "threeDS",
+				amount: payment.amount,
+				currencyCode: result.cart.currencyCode,
+				expiresAt: payment.action?.expiresAt ?? null,
+				publicConfiguration: payment.action?.publicConfiguration ?? {},
+				actionUrl: null,
+				clientSecret: null,
+				qrCode: null,
+				receiptUrl: null,
+				voucherCode: null,
+				qrImageUrl: null
+			}
+		} }, { headers: cookies });
+	}
+	if (result.payment?.actionKind === "embedded" && result.payment.providerId === "stripe" && providerPaymentMethodId !== void 0) {
+		const payment = result.payment;
+		return data({ authentication: {
+			orderStatusUrl: result.orderStatusUrl,
+			payment: {
+				transactionId: payment.transactionId,
+				externalId: payment.externalId,
+				providerId: payment.providerId ?? null,
+				paymentMethodCode: payment.paymentMethodCode,
+				isCaptured: false,
+				actionKind: "embedded",
+				amount: payment.amount,
+				currencyCode: result.cart.currencyCode,
+				expiresAt: payment.action?.expiresAt ?? null,
+				publicConfiguration: payment.action?.publicConfiguration ?? {},
+				actionUrl: null,
+				clientSecret: payment.action?.clientSecret ?? null,
+				qrCode: null,
+				receiptUrl: null,
+				voucherCode: null,
+				qrImageUrl: null
+			}
+		} }, { headers: cookies });
+	}
+	const url = result.payment?.action?.url;
+	if (result.payment?.actionKind === "redirect" && url) return redirect(url, { headers: cookies });
+	if (result.payment && (result.payment.actionKind !== "none" || paysOutsideCheckout(result.payment))) return redirect(result.orderStatusUrl, { headers: cookies });
+	return redirect(`/checkout/done?order=${encodeURIComponent(result.orderId)}`, { headers: cookies });
+}
+function paysOutsideCheckout(payment) {
+	return payment.providerId === "manual" && payment.paymentMethodCode !== "cash_on_delivery";
+}
+async function saveDetails(client, token, form) {
+	const contact = await saveContact(client, token, form);
+	if (!(contact instanceof Response)) return contact;
+	if (needsShipping(await client.getCart({ cartToken: token }))) {
+		const delivery = await saveDelivery(client, token, form);
+		if (!(delivery instanceof Response)) return delivery;
+		const shipping = await saveShipping(client, token, form);
+		if (!(shipping instanceof Response)) return shipping;
+	}
+	return null;
+}
+async function checkoutAll(client, token, form, headers, tracked) {
+	const unsaved = await saveDetails(client, token, form);
+	if (unsaved !== null) return unsaved;
+	return pay(client, token, form, headers, tracked);
+}
+const CHECKOUT_ERRORS = {
+	"Catalog.InsufficientStock": "Ya no hay stock suficiente de un producto. Revisa tu carrito.",
+	"Inventory.InsufficientStock": "Ya no hay stock suficiente de un producto. Revisa tu carrito.",
+	"Checkout.InProgress": "Tu pago se está procesando. Espera un momento antes de volver a intentar.",
+	"Checkout.PaymentMethodChanged": "Este pedido se calculó con otro medio de pago. Paga con ese medio o empieza otra compra.",
+	"Checkout.OrderNotActive": "Este pedido ya no está activo. Empieza una compra nueva.",
+	"Payments.MethodNotAvailable": "Ese medio de pago ya no está disponible. Elige otro.",
+	"Payments.Rejected": "No pudimos cobrar tu pago. Prueba con otra tarjeta o elige otro medio de pago.",
+	"Payments.InvalidPayerEmail": "La pasarela de pago no pudo validar tu correo. Revisa que esté bien escrito o usa otro.",
+	"Carts.NotActive": "Esta compra ya terminó. Vuelve a la tienda para empezar otra.",
+	"Order.DomesticShippingRequired": "La entrega debe ser dentro del país de la tienda."
+};
+async function checkoutAction(request, context) {
+	const current = await customer(request, context);
+	if (current) await requireCustomerRegistration(request, context, current);
+	const token = await cartToken(request);
+	if (token === null) throw redirect("/cart");
+	const client = store(context);
+	const form = await request.formData();
+	const intent = text(form, "intent");
+	if (!isIntent(CHECKOUT_INTENTS, intent)) return failure("Acción no válida.");
+	try {
+		if (intent === "contact") return await saveContact(client, token, form);
+		if (intent === "delivery") return await saveDelivery(client, token, form);
+		if (intent === "shipping") return await saveShipping(client, token, form);
+		if (intent === "payment-method") return await savePaymentMethod(client, token, form);
+		if (intent === "promo") {
+			const code = text(form, "code");
+			if (code) await client.addCartPromotionCode({
+				cartToken: token,
+				code
+			});
+			return redirect("/checkout");
+		}
+		if (intent === "promo-remove") {
+			await client.removeCartPromotionCode({
+				cartToken: token,
+				code: text(form, "code")
+			});
+			return redirect("/checkout");
+		}
+		if (intent === "bump") {
+			await client.addCartItem({
+				cartToken: token,
+				variantId: text(form, "variantId"),
+				quantity: 1,
+				orderBumpId: text(form, "bumpId")
+			});
+			return redirect("/checkout");
+		}
+		if (intent === "pay" || intent === "checkout") {
+			const tracked = await client.getSettings().then((settings) => trackingConsented(request, settings), () => false);
+			const headers = current ? customerHeaders(current) : void 0;
+			if (intent === "checkout") return await checkoutAll(client, token, form, headers, tracked);
+			return await pay(client, token, form, headers, tracked);
+		}
+		return failure("Acción no válida.");
+	} catch (error) {
+		const apiError = error instanceof ApiError ? error : void 0;
+		const functional = apiError !== void 0 && apiError.status >= 400 && apiError.status < 500;
+		const promo = intent === "promo" && functional && [
+			400,
+			409,
+			422
+		].includes(apiError.status);
+		let message = "No pudimos continuar con la compra. Intenta de nuevo.";
+		if (functional) {
+			message = promo ? "Ese código no es válido para tu carrito." : "Revisa los datos e intenta de nuevo.";
+			if (apiError.status === 401) message = "Tu sesión venció. Vuelve a ingresar.";
+			if (apiError.status === 403) message = "No tienes acceso a esta compra.";
+			if (apiError.status === 404) message = "El carrito o la opción elegida ya no está disponible.";
+			if (apiError.status === 429) message = "Espera un momento antes de volver a intentar.";
+			if (apiError.code !== void 0) message = CHECKOUT_ERRORS[apiError.code] ?? message;
+		}
+		const status = functional ? apiError.status : apiError?.status === 0 ? 503 : 502;
+		return data({
+			error: message,
+			promo,
+			code: apiError?.code,
+			traceId: apiError?.traceId
+		}, { status });
+	}
+}
+export { checkoutAction, checkoutAddressDefaults, checkoutProgress, checkoutStep, defaultPaymentMethod, loadCheckout, needsShipping, shouldRevalidateCheckout };