@ecomiq/storefront 2.1.4 → 3.0.1

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;

package/dist/culqi-checkout-CTXpKgp_.js

@@ -0,0 +1,55 @@
+// src/culqi-checkout.ts
+const CULQI_TOKEN_METHODS = /* @__PURE__ */ new Map([["card", {
+	tarjeta: true,
+	yape: false,
+	billetera: false,
+	bancaMovil: false,
+	agente: false,
+	cuotealo: false
+}], ["yape", {
+	tarjeta: false,
+	yape: true,
+	billetera: false,
+	bancaMovil: false,
+	agente: false,
+	cuotealo: false
+}]]);
+const CULQI_ORDER_METHODS = /* @__PURE__ */ new Map([["plin", {
+	tarjeta: false,
+	yape: false,
+	billetera: true,
+	bancaMovil: false,
+	agente: false,
+	cuotealo: false
+}], ["pagoefectivo", {
+	tarjeta: false,
+	yape: false,
+	billetera: false,
+	bancaMovil: true,
+	agente: true,
+	cuotealo: false
+}]]);
+let loading;
+function loadCulqiCheckout() {
+	if (window.CulqiCheckout) return Promise.resolve(window.CulqiCheckout);
+	if (loading) return loading;
+	loading = new Promise((resolve, reject) => {
+		const script = document.createElement("script");
+		script.src = "https://js.culqi.com/checkout-js";
+		script.async = true;
+		script.onload = () => {
+			if (window.CulqiCheckout) resolve(window.CulqiCheckout);
+			else reject(/* @__PURE__ */ new Error("No pudimos abrir el pago."));
+		};
+		script.onerror = () => {
+			script.remove();
+			reject(/* @__PURE__ */ new Error("No pudimos cargar el pago. Revisa tu conexión e intenta de nuevo."));
+		};
+		document.head.appendChild(script);
+	}).catch((error) => {
+		loading = void 0;
+		throw error;
+	});
+	return loading;
+}
+export { CULQI_ORDER_METHODS, CULQI_TOKEN_METHODS, loadCulqiCheckout };

package/dist/culqi-three-ds-HP3mfrvV.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+// src/culqi-three-ds.ts
+const CulqiPaymentSourceSchema = z.object({
+	token: z.string().min(1),
+	deviceSessionId: z.string().min(1)
+});
+let loading;
+function loadCulqiThreeDS() {
+	if (window.Culqi3DS) return Promise.resolve(window.Culqi3DS);
+	if (loading) return loading;
+	loading = new Promise((resolve, reject) => {
+		const script = document.createElement("script");
+		script.src = "https://3ds.culqi.com";
+		script.async = true;
+		script.onload = () => {
+			if (window.Culqi3DS) resolve(window.Culqi3DS);
+			else reject(/* @__PURE__ */ new Error("No pudimos cargar la autenticación de tarjeta."));
+		};
+		script.onerror = () => {
+			script.remove();
+			reject(/* @__PURE__ */ new Error("No pudimos cargar la autenticación de tarjeta."));
+		};
+		document.head.appendChild(script);
+	}).catch((error) => {
+		loading = void 0;
+		throw error;
+	});
+	return loading;
+}
+function culqiSourceKey(transactionId) {
+	return `ecomiq:culqi:${transactionId}`;
+}
+export { CulqiPaymentSourceSchema, culqiSourceKey, loadCulqiThreeDS };

package/dist/culqi-three-ds.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const CulqiPaymentSourceSchema: z.ZodObject<{
+  token: z.ZodString;
+  deviceSessionId: z.ZodString;
+}, z.core.$strip>;
+export type CulqiPaymentSource = z.infer<typeof CulqiPaymentSourceSchema>;
+type CulqiThreeDS = {
+  publicKey: string;
+  settings: {
+    charge: {
+      totalAmount: number;
+      currency: string;
+      returnUrl: string;
+    };
+    card: {
+      email: string;
+    };
+  };
+  generateDevice: () => Promise<string | null>;
+  initAuthentication: (token: string) => void;
+  reset: () => void;
+};
+declare global {
+  interface Window {
+    Culqi3DS?: CulqiThreeDS;
+  }
+}
+export declare function culqiSourceKey(transactionId: string): string;
+export {};

package/dist/customer-avatar-CJXSDroK.js

@@ -0,0 +1,12 @@
+import { jsx } from "react/jsx-runtime";
+// src/customer-avatar.tsx
+/** The signed-in customer's initial, drawn in the header's text color. */
+function CustomerAvatar({ name, className = "" }) {
+	const initial = name.trim().charAt(0).toLocaleUpperCase() || "?";
+	return /* @__PURE__ */ jsx("span", {
+		"aria-hidden": "true",
+		className: `inline-flex shrink-0 items-center justify-center rounded-full border-[1.5px] border-current font-semibold leading-none ${className}`,
+		children: initial
+	});
+}
+export { CustomerAvatar };

package/dist/customer-avatar.d.ts

@@ -0,0 +1,5 @@
+/** The signed-in customer's initial, drawn in the header's text color. */
+export declare function CustomerAvatar({ name, className }: {
+  name: string;
+  className?: string;
+}): import("react").JSX.Element;

package/dist/customer-cookies-DHOgFAMV.js

@@ -0,0 +1,45 @@
+import { createCookie } from "react-router";
+// src/customer-cookies.ts
+const CUSTOMER_COOKIE = "__Host-ecomiq-customer";
+const cookies = /* @__PURE__ */ new Map();
+function customerCookies(env) {
+	const secret = env.SESSION_SECRET;
+	if (!secret) throw new Error("Falta SESSION_SECRET en el worker.");
+	let saved = cookies.get(secret);
+	if (!saved) {
+		const options = {
+			httpOnly: true,
+			sameSite: "lax",
+			secure: true,
+			path: "/",
+			secrets: [secret]
+		};
+		saved = {
+			session: createCookie(CUSTOMER_COOKIE, options),
+			transaction: createCookie("__Host-ecomiq-customer-login", {
+				...options,
+				maxAge: 600
+			})
+		};
+		cookies.set(secret, saved);
+	}
+	return saved;
+}
+async function customerSessionId(request, env) {
+	const value = await customerCookies(env).session.parse(request.headers.get("Cookie"));
+	return typeof value === "string" && value.length > 0 && value.length <= 256 ? value : null;
+}
+function base64Url(bytes) {
+	return btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlBytes(value) {
+	const base64 = value.replace(/-/g, "+").replace(/_/g, "/");
+	return Uint8Array.from(atob(base64 + "=".repeat((4 - base64.length % 4) % 4)), (character) => character.charCodeAt(0));
+}
+function equalSecret(left, right) {
+	if (left.length !== right.length) return false;
+	let difference = 0;
+	for (let index = 0; index < left.length; index += 1) difference |= left.charCodeAt(index) ^ right.charCodeAt(index);
+	return difference === 0;
+}
+export { CUSTOMER_COOKIE, base64Url, base64UrlBytes, customerCookies, customerSessionId, equalSecret };