@ecomiq/storefront 2.1.4 → 3.0.0

package/dist/checkout-form-CbOIdENC.js

@@ -0,0 +1,131 @@
+import { CustomerCsrfField } from "./customer-csrf-C1oDX-Py.js";
+import { usePageAction } from "./page-action-Ctkf4xC6.js";
+import { Form, useFetcher, useSubmit } from "react-router";
+import { useEffect, useRef } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+// src/checkout-form.tsx
+const CHECKOUT_ACTION = "/checkout";
+const AUTOSAVE_MS = 700;
+const GATHERED = /* @__PURE__ */ new Set([
+	"contact",
+	"delivery",
+	"shipping"
+]);
+function gathered(own) {
+	const data = new FormData(own);
+	for (const form of document.querySelectorAll("form[data-checkout-intent]")) {
+		if (form === own || !GATHERED.has(form.dataset.checkoutIntent ?? "")) continue;
+		if (!form.reportValidity()) return null;
+		for (const [key, value] of new FormData(form)) if (key !== "intent" && !data.has(key)) data.append(key, value);
+	}
+	data.set("intent", "checkout");
+	return data;
+}
+function CheckoutForm({ intent, single = false, children, onChange, onClick, onSubmit, ...props }) {
+	const action = usePageAction(CHECKOUT_ACTION);
+	const fetcher = useFetcher();
+	const submit = useSubmit();
+	const timer = useRef(void 0);
+	useEffect(() => () => window.clearTimeout(timer.current), []);
+	const autosave = single && (intent === "delivery" || intent === "shipping");
+	const schedule = (form) => {
+		if (!autosave) return;
+		window.clearTimeout(timer.current);
+		timer.current = window.setTimeout(() => {
+			if (form.checkValidity()) fetcher.submit(form, {
+				method: "post",
+				action,
+				preventScrollReset: true
+			});
+		}, intent === "shipping" ? 0 : AUTOSAVE_MS);
+	};
+	const changed = (event) => {
+		onChange?.(event);
+		schedule(event.currentTarget);
+	};
+	const clicked = (event) => {
+		onClick?.(event);
+		if (event.target instanceof HTMLInputElement && event.target.type === "radio") schedule(event.currentTarget);
+	};
+	const sent = (event) => {
+		onSubmit?.(event);
+		if (!single || intent !== "pay" || event.defaultPrevented) return;
+		event.preventDefault();
+		const data = gathered(event.currentTarget);
+		if (data === null) return;
+		submit(data, {
+			method: "post",
+			action,
+			encType: "multipart/form-data"
+		});
+	};
+	return /* @__PURE__ */ jsxs(Form, {
+		method: "post",
+		action,
+		encType: intent === "pay" ? "multipart/form-data" : void 0,
+		"data-checkout-intent": intent,
+		onChange: changed,
+		onClick: clicked,
+		onSubmit: sent,
+		...props,
+		children: [
+			/* @__PURE__ */ jsx(CustomerCsrfField, {}),
+			/* @__PURE__ */ jsx("input", {
+				type: "hidden",
+				name: "intent",
+				value: intent
+			}),
+			children
+		]
+	});
+}
+function OrderBumpForm({ bump, children, ...props }) {
+	const action = usePageAction(CHECKOUT_ACTION);
+	return /* @__PURE__ */ jsxs(Form, {
+		method: "post",
+		action,
+		...props,
+		children: [
+			/* @__PURE__ */ jsx(CustomerCsrfField, {}),
+			/* @__PURE__ */ jsx("input", {
+				type: "hidden",
+				name: "intent",
+				value: "bump"
+			}),
+			/* @__PURE__ */ jsx("input", {
+				type: "hidden",
+				name: "bumpId",
+				value: bump.id
+			}),
+			/* @__PURE__ */ jsx("input", {
+				type: "hidden",
+				name: "variantId",
+				value: bump.variantId
+			}),
+			children
+		]
+	});
+}
+function PromoCodeForm({ remove, children, ...props }) {
+	const action = usePageAction(CHECKOUT_ACTION);
+	return /* @__PURE__ */ jsxs(Form, {
+		method: "post",
+		action,
+		...props,
+		children: [
+			/* @__PURE__ */ jsx(CustomerCsrfField, {}),
+			/* @__PURE__ */ jsx("input", {
+				type: "hidden",
+				name: "intent",
+				value: remove === void 0 ? "promo" : "promo-remove"
+			}),
+			remove === void 0 ? null : /* @__PURE__ */ jsx("input", {
+				type: "hidden",
+				name: "code",
+				value: remove
+			}),
+			children
+		]
+	});
+}
+export { CHECKOUT_ACTION, CheckoutForm, OrderBumpForm, PromoCodeForm, gathered };

package/dist/checkout-form.d.ts

@@ -0,0 +1,20 @@
+import { CheckoutIntent } from "./form-contracts.js";
+import { FetcherFormProps } from "react-router";
+type FormProps = Omit<FetcherFormProps, "action" | "method" | "encType">;
+export type CheckoutFormProps = FormProps & {
+  intent: Exclude<CheckoutIntent, "bump" | "promo" | "promo-remove" | "checkout">;
+  single?: boolean;
+};
+export type OrderBumpFormProps = FormProps & {
+  bump: {
+    id: string;
+    variantId: string;
+  };
+};
+export type PromoCodeFormProps = FormProps & {
+  remove?: string;
+};
+export declare function CheckoutForm({ intent, single, children, onChange, onClick, onSubmit, ...props }: CheckoutFormProps): import("react").JSX.Element;
+export declare function OrderBumpForm({ bump, children, ...props }: OrderBumpFormProps): import("react").JSX.Element;
+export declare function PromoCodeForm({ remove, children, ...props }: PromoCodeFormProps): import("react").JSX.Element;
+export {};

package/dist/checkout.d.ts

@@ -0,0 +1,86 @@
+import { AddressDefaults } from "./address-defaults.js";
+import { PageAnalytics } from "./analytics/events.js";
+import { readCountries } from "./store.js";
+import { RouterContextProvider, ShouldRevalidateFunctionArgs } from "react-router";
+import { CartCheckoutReadResponse, CustomerAddress, CustomerMe, ShippingOptionGroup, ShippingRate, StorefrontCart } from "@ecomiq/core";
+import { z } from "zod";
+export type CheckoutStep = "contact" | "delivery" | "shipping" | "payment";
+export type CheckoutRate = ShippingRate & {
+  value: string;
+};
+export type CheckoutShippingGroup = Omit<ShippingOptionGroup, "rates"> & {
+  field: string;
+  rates: CheckoutRate[];
+};
+export type CheckoutPaymentMethod = CartCheckoutReadResponse["paymentMethods"]["methods"][number];
+export type CheckoutData = {
+  countryCode: string;
+  documentCountries: {
+    code: string;
+    name: string;
+  }[];
+  language: string;
+  cart: StorefrontCart;
+  methods: CheckoutPaymentMethod[];
+  bumps: CartCheckoutReadResponse["orderBumps"];
+  signedIn: boolean;
+  me: CustomerMe | null;
+  address: CustomerAddress | null;
+  countries: Awaited<ReturnType<typeof readCountries>>;
+  shipping: CheckoutShippingGroup[];
+  analytics: PageAnalytics;
+};
+declare const CheckoutAuthenticationSchema: z.ZodObject<{
+  authentication: z.ZodObject<{
+    payment: z.ZodObject<{
+      actionUrl: z.ZodNullable<z.ZodString>;
+      isCaptured: z.ZodBoolean;
+      transactionId: z.ZodNullable<z.ZodString>;
+      externalId: z.ZodNullable<z.ZodString>;
+      actionKind: z.ZodEnum<{
+        embedded: "embedded";
+        none: "none";
+        qrCode: "qrCode";
+        redirect: "redirect";
+        threeDS: "threeDS";
+        voucher: "voucher";
+      }>;
+      providerId: z.ZodNullable<z.ZodString>;
+      publicConfiguration: z.ZodObject<{
+        publishableKey: z.ZodOptional<z.ZodString>;
+        publicKey: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      clientSecret: z.ZodNullable<z.ZodString>;
+      qrCode: z.ZodNullable<z.ZodString>;
+      receiptUrl: z.ZodNullable<z.ZodString>;
+      expiresAt: z.ZodNullable<z.ZodString>;
+      paymentMethodCode: z.ZodNullable<z.ZodString>;
+      amount: z.ZodNullable<z.ZodNumber>;
+      currencyCode: z.ZodNullable<z.ZodString>;
+      voucherCode: z.ZodNullable<z.ZodString>;
+      qrImageUrl: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    orderStatusUrl: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+export type CheckoutAuthenticationData = z.infer<typeof CheckoutAuthenticationSchema>;
+export type CheckoutActionData = {
+  error: string;
+  promo: boolean;
+  code?: string;
+  traceId?: string;
+} | CheckoutAuthenticationData;
+export type CheckoutAddressDefaults = AddressDefaults;
+export declare function shouldRevalidateCheckout({ actionResult, defaultShouldRevalidate }: ShouldRevalidateFunctionArgs): boolean;
+export declare function needsShipping(cart: StorefrontCart): boolean;
+export declare function checkoutProgress(cart: StorefrontCart): {
+  contact: boolean;
+  delivery: boolean;
+  shipping: boolean;
+};
+export declare function checkoutStep(cart: StorefrontCart, edit: string | null): CheckoutStep;
+export declare function checkoutAddressDefaults(cart: StorefrontCart, address: CustomerAddress | null, countryCode: string): CheckoutAddressDefaults;
+export declare function defaultPaymentMethod(cart: StorefrontCart, methods: CheckoutPaymentMethod[]): string | undefined;
+export declare function loadCheckout(request: Request, context: Readonly<RouterContextProvider>): Promise<CheckoutData>;
+export declare function checkoutAction(request: Request, context: Readonly<RouterContextProvider>): Promise<import("react-router").UNSAFE_DataWithResponseInit<CheckoutActionData> | Response>;
+export {};

package/dist/complaint-book-BvwLvfx0.js

@@ -0,0 +1,117 @@
+import { captchaResponse } from "./captcha-DAqaIx8m.js";
+import { COMPLAINT_DOCUMENT_TYPES, identityDocumentError } from "./documents-T1mzc_j8.js";
+import { optional, text } from "./form-BtQcbXlJ.js";
+import { rejectCrossOriginAction } from "./request-security-CRsRMgwj.js";
+import { found, readDocumentCountries, store } from "./store-8Q-_LFrQ.js";
+import { data } from "react-router";
+import { ApiError, COMPLAINT_BOOK_ATTACHMENT_TYPES, COMPLAINT_BOOK_MAX_ATTACHMENTS, COMPLAINT_BOOK_MAX_ATTACHMENT_BYTES, ComplaintBookEntryInputSchema } from "@ecomiq/core";
+import { z } from "zod";
+// src/complaint-book.ts
+const TOO_MANY_ATTACHMENTS = "Adjunta hasta 3 archivos.";
+const INVALID_ATTACHMENT = "Adjunta fotos (JPG, PNG o WebP) o PDF de hasta 5 MB.";
+const COMPLAINT_BOOK_ERRORS = {
+	"ComplaintBook.Captcha": "Completa la verificación de seguridad.",
+	"ComplaintBook.Unavailable": "El Libro de Reclamaciones no está disponible en esta tienda.",
+	"ComplaintBook.TooManyAttachments": TOO_MANY_ATTACHMENTS,
+	"ComplaintBook.InvalidAttachment": INVALID_ATTACHMENT,
+	"ComplaintBook.AttachmentUploadFailed": "No pudimos guardar los adjuntos. Intenta de nuevo o envía sin ellos."
+};
+const ValidationProblemSchema = z.object({ fieldErrors: z.record(z.string(), z.array(z.string())) });
+function complaintBookLinks(settings) {
+	if (settings.store.countryCode !== "PE") return [];
+	return [{
+		label: "Libro de Reclamaciones",
+		url: "/libro-de-reclamaciones"
+	}];
+}
+function complaintBookNumber(number) {
+	return `N.° ${String(number).padStart(6, "0")}`;
+}
+function complaintBookAttachmentError(files) {
+	if (files.length > COMPLAINT_BOOK_MAX_ATTACHMENTS) return TOO_MANY_ATTACHMENTS;
+	if (files.some((file) => file.size === 0 || file.size > COMPLAINT_BOOK_MAX_ATTACHMENT_BYTES || !COMPLAINT_BOOK_ATTACHMENT_TYPES.includes(file.type))) return INVALID_ATTACHMENT;
+	return null;
+}
+async function loadComplaintBook(context) {
+	const client = store(context);
+	const [book, settings] = await Promise.all([found(client.getComplaintBook()), client.getSettings()]);
+	return {
+		book,
+		countryCode: settings.store.countryCode,
+		language: settings.store.language,
+		timeZone: settings.store.timeZone,
+		countries: await readDocumentCountries(client)
+	};
+}
+function failure(error, status = 400) {
+	return data({ error }, { status });
+}
+function person(form, prefix) {
+	return {
+		name: text(form, `${prefix}Name`),
+		address: text(form, `${prefix}Address`),
+		phone: text(form, `${prefix}Phone`),
+		email: text(form, `${prefix}Email`)
+	};
+}
+function complaintEntry(form) {
+	if (form.get("confirmed") !== "on") return "Confirma que los datos son verdaderos.";
+	const amount = optional(form, "itemAmount");
+	const parsed = ComplaintBookEntryInputSchema.safeParse({
+		type: text(form, "type"),
+		consumer: {
+			...person(form, "consumer"),
+			documentType: text(form, "documentType"),
+			documentNumber: text(form, "documentNumber"),
+			documentCountryCode: text(form, "documentCountryCode")
+		},
+		guardian: form.get("minor") === "on" ? person(form, "guardian") : null,
+		item: {
+			kind: text(form, "itemKind"),
+			description: text(form, "itemDescription"),
+			amount: amount === null ? null : Number(amount)
+		},
+		orderNumber: optional(form, "orderNumber"),
+		detail: text(form, "detail"),
+		request: text(form, "request"),
+		confirmed: true
+	});
+	if (!parsed.success) return "Completa los datos obligatorios.";
+	const { documentType, documentNumber, documentCountryCode } = parsed.data.consumer;
+	const documentError = identityDocumentError(COMPLAINT_DOCUMENT_TYPES[documentType], documentCountryCode, documentNumber);
+	if (documentError !== null) return documentError;
+	return parsed.data;
+}
+function apiErrorMessage(error) {
+	const problem = ValidationProblemSchema.safeParse(error.body);
+	const codes = problem.success ? Object.values(problem.data.fieldErrors).flat() : [];
+	if (error.code !== void 0) codes.unshift(error.code);
+	return codes.flatMap((code) => COMPLAINT_BOOK_ERRORS[code] ?? [])[0];
+}
+async function complaintBookAction(request, context) {
+	const rejected = rejectCrossOriginAction(request);
+	if (rejected) return rejected;
+	const client = store(context);
+	const form = await request.formData();
+	const book = await found(client.getComplaintBook());
+	const token = captchaResponse(form, book.captcha.provider);
+	if (!token) return failure("Completa la verificación de seguridad.");
+	const sheet = complaintEntry(form);
+	if (typeof sheet === "string") return failure(sheet);
+	const files = form.getAll("files").filter((file) => file instanceof File && file.size > 0);
+	const attachmentError = complaintBookAttachmentError(files);
+	if (attachmentError) return failure(attachmentError);
+	try {
+		return {
+			entry: await client.createComplaintBookEntry(sheet, files, token),
+			sheet,
+			attachments: files.map((file) => file.name)
+		};
+	} catch (error) {
+		if (!(error instanceof ApiError) || error.status === 0 || error.status >= 500) return failure("No pudimos registrar tu reclamo. Intenta de nuevo.", 503);
+		let message = "Revisa los datos e intenta de nuevo.";
+		if (error.status === 429) message = "Espera un momento antes de volver a intentar.";
+		return failure(apiErrorMessage(error) ?? message, error.status);
+	}
+}
+export { complaintBookAction, complaintBookAttachmentError, complaintBookLinks, complaintBookNumber, loadComplaintBook };

package/dist/complaint-book.d.ts

@@ -0,0 +1,62 @@
+import { RouterContextProvider } from "react-router";
+import { ComplaintBook, ComplaintBookEntry, ComplaintBookEntryInput, StorefrontSettings } from "@ecomiq/core";
+export type ComplaintBookLink = {
+  label: string;
+  url: string;
+};
+export type ComplaintBookData = {
+  book: ComplaintBook;
+  countryCode: string;
+  language: string;
+  timeZone: string;
+  countries: {
+    code: string;
+    name: string;
+  }[];
+};
+export type ComplaintBookActionData = {
+  error: string;
+} | {
+  entry: ComplaintBookEntry;
+  sheet: ComplaintBookEntryInput;
+  attachments: string[];
+};
+export declare function complaintBookLinks(settings: StorefrontSettings): ComplaintBookLink[];
+export declare function complaintBookNumber(number: number): string;
+export declare function complaintBookAttachmentError(files: readonly File[]): string | null;
+export declare function loadComplaintBook(context: Readonly<RouterContextProvider>): Promise<ComplaintBookData>;
+export declare function complaintBookAction(request: Request, context: Readonly<RouterContextProvider>): Promise<import("react-router").UNSAFE_DataWithResponseInit<ComplaintBookActionData> | Response | {
+  entry: {
+    number: number;
+    filedOn: string;
+    responseDueOn: string;
+  };
+  sheet: {
+    type: "claim" | "complaint";
+    consumer: {
+      name: string;
+      address: string;
+      phone: string;
+      email: string;
+      documentType: "foreignId" | "nationalId" | "passport" | "taxId";
+      documentNumber: string;
+      documentCountryCode: string;
+    };
+    guardian: {
+      name: string;
+      address: string;
+      phone: string;
+      email: string;
+    } | null;
+    item: {
+      kind: "product" | "service";
+      description: string;
+      amount: number | null;
+    };
+    orderNumber: string | null;
+    detail: string;
+    request: string;
+    confirmed: true;
+  };
+  attachments: string[];
+}>;

package/dist/culqi-authentication-BGr20vAJ.js

@@ -0,0 +1,204 @@
+import { useStorefrontLocale, useStorefrontText } from "./storefront-language-DrMjVbmk.js";
+import { useCustomerCsrfToken } from "./customer-csrf-C1oDX-Py.js";
+import { CulqiPaymentSourceSchema, culqiSourceKey, loadCulqiThreeDS } from "./culqi-three-ds-HP3mfrvV.js";
+import { useNavigate, useSubmit } from "react-router";
+import { PaymentAuthentication3DSSchema } from "@ecomiq/core";
+import { z } from "zod";
+import { useEffect, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+// src/culqi-authentication.tsx
+const StoredSourceSchema = CulqiPaymentSourceSchema.extend({
+	expiresAt: z.string().datetime({ offset: true }),
+	orderStatusUrl: z.string()
+});
+const AuthenticationMessageSchema = z.union([z.object({ parameters3DS: PaymentAuthentication3DSSchema }), z.object({ error: z.string() })]);
+function useOrderAuthentication({ result, payment, orderStatusUrl }) {
+	useEffect(() => {
+		let storage;
+		try {
+			storage = window.sessionStorage;
+		} catch {
+			return;
+		}
+		for (let index = storage.length - 1; index >= 0; index--) {
+			const key = storage.key(index);
+			if (key === null || !key.startsWith("ecomiq:culqi:")) continue;
+			let stored;
+			try {
+				stored = JSON.parse(storage.getItem(key) ?? "null");
+			} catch {
+				storage.removeItem(key);
+				continue;
+			}
+			const source = StoredSourceSchema.safeParse(stored);
+			if (!source.success || Date.parse(source.data.expiresAt) <= Date.now() || source.data.orderStatusUrl === orderStatusUrl && (payment?.actionKind !== "threeDS" || key !== culqiSourceKey(payment.transactionId ?? ""))) storage.removeItem(key);
+		}
+		if (result?.authenticatedTransactionId) storage.removeItem(culqiSourceKey(result.authenticatedTransactionId));
+	}, [
+		result?.authenticatedTransactionId,
+		payment?.actionKind,
+		payment?.transactionId,
+		orderStatusUrl
+	]);
+}
+function CulqiAuthentication({ payment, orderStatusUrl, email, source, result }) {
+	const storefrontTranslate = useStorefrontText();
+	const { locale, timeZone } = useStorefrontLocale();
+	const expiry = new Intl.DateTimeFormat(locale, {
+		dateStyle: "medium",
+		timeStyle: "short",
+		timeZone
+	});
+	const submit = useSubmit();
+	const navigate = useNavigate();
+	const csrf = useCustomerCsrfToken();
+	const [error, setError] = useState(null);
+	const [retryable, setRetryable] = useState(false);
+	const [attempt, setAttempt] = useState(0);
+	const authenticationSubmission = useRef(null);
+	useEffect(() => {
+		authenticationSubmission.current = null;
+		let active = true;
+		let sent = false;
+		let reset;
+		let timer;
+		let receive;
+		const transactionId = payment.transactionId;
+		async function authenticate() {
+			if (transactionId === null || payment.expiresAt === null) throw new Error("No pudimos iniciar la autenticación de este pago.");
+			const key = culqiSourceKey(transactionId);
+			if (source !== null) window.sessionStorage.setItem(key, JSON.stringify({
+				...source,
+				expiresAt: payment.expiresAt,
+				orderStatusUrl
+			}));
+			let storedValue;
+			try {
+				storedValue = JSON.parse(window.sessionStorage.getItem(key) ?? "null");
+			} catch {
+				storedValue = null;
+			}
+			const stored = StoredSourceSchema.safeParse(storedValue);
+			if (!stored.success || stored.data.orderStatusUrl !== orderStatusUrl) throw new Error("La sesión de tu tarjeta terminó. Espera a que venza esta autenticación y vuelve al estado del pedido para intentar el pago.");
+			const remaining = Date.parse(stored.data.expiresAt) - Date.now();
+			if (remaining <= 0) {
+				window.sessionStorage.removeItem(key);
+				throw new Error("La autenticación venció. Vuelve al pedido para consultar las opciones de pago.");
+			}
+			if (window.location.pathname !== new URL(orderStatusUrl, window.location.href).pathname) {
+				navigate(orderStatusUrl, { replace: true });
+				return;
+			}
+			if (!payment.publicConfiguration.publicKey || payment.amount === null || payment.currencyCode === null || !email) throw new Error("No pudimos iniciar la autenticación de este pago.");
+			setRetryable(true);
+			timer = window.setTimeout(() => {
+				active = false;
+				window.sessionStorage.removeItem(key);
+				reset?.();
+				setRetryable(false);
+				setError("La autenticación venció. Vuelve al pedido para consultar las opciones de pago.");
+			}, remaining);
+			const sdk = await loadCulqiThreeDS();
+			if (!active) return;
+			sdk.reset();
+			reset = () => sdk.reset();
+			sdk.publicKey = payment.publicConfiguration.publicKey;
+			sdk.settings = {
+				charge: {
+					totalAmount: Math.round(payment.amount * 100),
+					currency: payment.currencyCode,
+					returnUrl: window.location.href
+				},
+				card: { email }
+			};
+			receive = (event) => {
+				if (!active || sent || event.origin !== window.location.origin) return;
+				const response = AuthenticationMessageSchema.safeParse(event.data);
+				if (!response.success) return;
+				if ("error" in response.data) {
+					setError("No pudimos autenticar tu tarjeta. Intenta nuevamente.");
+					return;
+				}
+				sent = true;
+				const form = new FormData();
+				form.set("intent", "authenticate");
+				form.set("transactionId", transactionId);
+				form.set("token", stored.data.token);
+				form.set("deviceSessionId", stored.data.deviceSessionId);
+				form.set("authentication3DS", JSON.stringify(response.data.parameters3DS));
+				if (csrf) form.set("__customer_csrf", csrf);
+				authenticationSubmission.current = form;
+				submit(form, {
+					method: "post",
+					action: orderStatusUrl,
+					encType: "multipart/form-data"
+				});
+			};
+			window.addEventListener("message", receive);
+			sdk.initAuthentication(stored.data.token);
+		}
+		setError(null);
+		setRetryable(false);
+		authenticate().catch((error) => {
+			if (active) setError(error instanceof Error ? error.message : "No pudimos autenticar tu tarjeta.");
+		});
+		return () => {
+			active = false;
+			window.clearTimeout(timer);
+			if (receive) window.removeEventListener("message", receive);
+			reset?.();
+		};
+	}, [
+		payment.transactionId,
+		payment.expiresAt,
+		payment.publicConfiguration.publicKey,
+		payment.amount,
+		payment.currencyCode,
+		orderStatusUrl,
+		email,
+		source,
+		csrf,
+		submit,
+		navigate,
+		attempt
+	]);
+	const failure = error ?? (result?.ok === false ? result.message : null);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col gap-4 rounded-lg border p-6",
+		children: [
+			/* @__PURE__ */ jsx("p", {
+				role: "status",
+				children: storefrontTranslate("Confirma el pago con tu banco para completar el pedido.")
+			}),
+			payment.expiresAt ? /* @__PURE__ */ jsxs("p", { children: [
+				storefrontTranslate("La autenticación dura hasta 15 minutos y vence el"),
+				" ",
+				expiry.format(new Date(payment.expiresAt)),
+				"."
+			] }) : null,
+			failure ? /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("p", {
+				role: "alert",
+				children: failure
+			}), retryable ? /* @__PURE__ */ jsx("button", {
+				type: "button",
+				onClick: () => {
+					const form = authenticationSubmission.current;
+					if (form !== null) submit(form, {
+						method: "post",
+						action: orderStatusUrl,
+						encType: "multipart/form-data"
+					});
+					else setAttempt((value) => value + 1);
+				},
+				className: "underline",
+				children: authenticationSubmission.current === null ? "Reintentar autenticación" : "Reintentar confirmación"
+			}) : null] }) : null,
+			/* @__PURE__ */ jsx("a", {
+				href: orderStatusUrl,
+				className: "underline",
+				children: storefrontTranslate("Ver estado del pedido")
+			})
+		]
+	});
+}
+export { CulqiAuthentication, useOrderAuthentication };

package/dist/culqi-authentication.d.ts

@@ -0,0 +1,15 @@
+import { CulqiPaymentSource } from "./culqi-three-ds.js";
+import { OrderPaymentActionData } from "./order-status.js";
+import { OrderPaymentStart } from "@ecomiq/core";
+export declare function useOrderAuthentication({ result, payment, orderStatusUrl }: {
+  result: OrderPaymentActionData | undefined;
+  payment: OrderPaymentStart | null;
+  orderStatusUrl: string;
+}): void;
+export declare function CulqiAuthentication({ payment, orderStatusUrl, email, source, result }: {
+  payment: OrderPaymentStart;
+  orderStatusUrl: string;
+  email: string | null;
+  source: CulqiPaymentSource | null;
+  result?: OrderPaymentActionData;
+}): import("react").JSX.Element;