@ecomiq/storefront 2.1.4 → 3.0.1

package/dist/order-payment-continuation-D_d5PGA4.js

@@ -0,0 +1,212 @@
+import { useStorefrontText } from "./storefront-language-DrMjVbmk.js";
+import { VoucherPayment } from "./voucher-payment-CVFDZ1L8.js";
+import { useCulqiCheckout } from "./use-culqi-checkout-CrjLAipU.js";
+import { CulqiAuthentication } from "./culqi-authentication-BGr20vAJ.js";
+import { useRevalidator } from "react-router";
+import { useEffect, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+// src/order-payment-continuation.tsx
+function OrderPaymentContinuation({ payment, source = null, orderStatusUrl, email, result }) {
+	const storefrontTranslate = useStorefrontText();
+	const revalidator = useRevalidator();
+	useEffect(() => {
+		if (payment.isCaptured) return;
+		const timer = window.setInterval(() => {
+			revalidator.revalidate();
+		}, 1e4);
+		return () => window.clearInterval(timer);
+	}, [payment.isCaptured, revalidator.revalidate]);
+	if (payment.actionKind === "threeDS" && payment.providerId === "culqi" && orderStatusUrl && email) return /* @__PURE__ */ jsx(CulqiAuthentication, {
+		payment,
+		source,
+		orderStatusUrl,
+		email,
+		result
+	});
+	if (payment.actionKind === "embedded" && payment.providerId === "stripe") return /* @__PURE__ */ jsx(StripeOrderPayment, { payment });
+	if (payment.actionKind === "voucher" && payment.providerId === "culqi" && payment.externalId) return /* @__PURE__ */ jsx(CulqiOrderPayment, { payment });
+	if (payment.actionKind === "voucher") return /* @__PURE__ */ jsx(VoucherPayment, { payment });
+	if (payment.actionKind === "qrCode" && payment.qrCode) return /* @__PURE__ */ jsx(OrderPaymentQr, { code: payment.qrCode });
+	return /* @__PURE__ */ jsxs("p", {
+		role: "alert",
+		children: [storefrontTranslate("No pudimos abrir este medio de pago. Escríbenos para completar tu pedido."), " "]
+	});
+}
+function CulqiOrderPayment({ payment }) {
+	const storefrontTranslate = useStorefrontText();
+	const culqi = useCulqiCheckout();
+	const revalidator = useRevalidator();
+	const open = useRef(() => {});
+	open.current = () => {
+		if (payment.externalId === null || payment.paymentMethodCode === null || payment.amount === null || payment.currencyCode === null) return;
+		culqi.openOrder({
+			orderId: payment.externalId,
+			methodCode: payment.paymentMethodCode,
+			publicKey: payment.publicConfiguration.publicKey,
+			title: storefrontTranslate("Completa tu pago"),
+			currency: payment.currencyCode,
+			amount: payment.amount,
+			email: null
+		}, () => {
+			revalidator.revalidate();
+		});
+	};
+	useEffect(() => {
+		open.current();
+	}, [payment.externalId]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col gap-4",
+		children: [
+			/* @__PURE__ */ jsx(VoucherPayment, { payment }),
+			culqi.error ? /* @__PURE__ */ jsx("p", {
+				role: "alert",
+				children: culqi.error
+			}) : null,
+			/* @__PURE__ */ jsx("button", {
+				type: "button",
+				disabled: culqi.loading,
+				onClick: () => open.current(),
+				className: "rounded-md bg-primary px-4 py-3 font-medium text-primary-foreground disabled:opacity-50",
+				children: culqi.loading ? storefrontTranslate("Cargando el pago…") : storefrontTranslate("Abrir instrucciones de pago")
+			})
+		]
+	});
+}
+function OrderPaymentQr({ code }) {
+	const storefrontTranslate = useStorefrontText();
+	const [image, setImage] = useState(null);
+	useEffect(() => {
+		let disposed = false;
+		import("qrcode-generator").then(({ default: qrcode }) => {
+			if (disposed) return;
+			const qr = qrcode(0, "M");
+			qr.addData(code);
+			qr.make();
+			setImage(qr.createDataURL(5, 10));
+		});
+		return () => {
+			disposed = true;
+		};
+	}, [code]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col items-center gap-4 rounded-lg border p-6",
+		children: [
+			/* @__PURE__ */ jsx("p", { children: storefrontTranslate("Escanea el QR para completar tu pago.") }),
+			image === null ? /* @__PURE__ */ jsx("span", {
+				className: "size-60",
+				"aria-hidden": "true"
+			}) : /* @__PURE__ */ jsx("img", {
+				src: image,
+				alt: storefrontTranslate("Código QR de pago"),
+				width: 240,
+				height: 240,
+				className: "size-60"
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "text-sm text-muted-foreground",
+				role: "status",
+				children: storefrontTranslate("Confirmaremos tu pago al recibirlo.")
+			})
+		]
+	});
+}
+function StripeOrderPayment({ payment }) {
+	const storefrontTranslate = useStorefrontText();
+	const container = useRef(null);
+	const stripe = useRef(null);
+	const elements = useRef(null);
+	const [ready, setReady] = useState(false);
+	const [busy, setBusy] = useState(false);
+	const [error, setError] = useState(null);
+	const [submitted, setSubmitted] = useState(false);
+	const [attempt, setAttempt] = useState(0);
+	const revalidator = useRevalidator();
+	useEffect(() => {
+		let disposed = false;
+		let element;
+		setReady(false);
+		setError(null);
+		async function mount() {
+			const key = payment.publicConfiguration.publishableKey;
+			if (!key || !payment.clientSecret) throw new Error("El pago con tarjeta no está disponible. Escríbenos para completar tu pedido.");
+			const { loadStripe } = await import("@stripe/stripe-js/pure");
+			const client = await loadStripe(key);
+			if (disposed) return;
+			if (!client || !container.current) throw new Error("No pudimos cargar el pago con tarjeta.");
+			stripe.current = client;
+			elements.current = client.elements({ clientSecret: payment.clientSecret });
+			element = elements.current.create("payment");
+			element.on("ready", () => {
+				if (!disposed) setReady(true);
+			});
+			element.on("loaderror", () => {
+				if (!disposed) setError("No pudimos cargar el formulario. Revisa tu conexión e intenta de nuevo.");
+			});
+			element.mount(container.current);
+		}
+		mount().catch((error) => {
+			if (!disposed) setError(error instanceof Error ? error.message : "No pudimos cargar el pago con tarjeta.");
+		});
+		return () => {
+			disposed = true;
+			element?.destroy();
+			stripe.current = null;
+			elements.current = null;
+		};
+	}, [
+		payment.clientSecret,
+		payment.publicConfiguration.publishableKey,
+		attempt
+	]);
+	async function pay() {
+		if (!stripe.current || !elements.current || busy) return;
+		setBusy(true);
+		setError(null);
+		try {
+			const result = await stripe.current.confirmPayment({
+				elements: elements.current,
+				confirmParams: { return_url: window.location.href },
+				redirect: "if_required"
+			});
+			if (result.error) setError(result.error.message ?? "No pudimos procesar el pago. Revisa los datos de la tarjeta.");
+			else {
+				setSubmitted(true);
+				await revalidator.revalidate();
+			}
+		} catch {
+			setError("No pudimos confirmar el pago. Revisa su estado antes de intentar de nuevo.");
+		} finally {
+			setBusy(false);
+		}
+	}
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col gap-4 rounded-lg border p-6",
+		children: [
+			/* @__PURE__ */ jsx("div", { ref: container }),
+			error ? /* @__PURE__ */ jsx("p", {
+				role: "alert",
+				className: "text-sm text-destructive",
+				children: error
+			}) : null,
+			submitted ? /* @__PURE__ */ jsx("p", {
+				role: "status",
+				children: storefrontTranslate("Estamos confirmando tu pago.")
+			}) : /* @__PURE__ */ jsx("button", {
+				type: "button",
+				onClick: () => {
+					pay();
+				},
+				disabled: !ready || busy,
+				className: "rounded-md bg-primary px-4 py-3 font-medium text-primary-foreground disabled:opacity-50",
+				children: busy ? storefrontTranslate("Procesando…") : "Confirmar pago"
+			}),
+			error && !ready ? /* @__PURE__ */ jsxs("button", {
+				type: "button",
+				onClick: () => setAttempt((value) => value + 1),
+				className: "underline",
+				children: [storefrontTranslate("Reintentar"), " "]
+			}) : null
+		]
+	});
+}
+export { OrderPaymentContinuation };

package/dist/order-payment-continuation.d.ts

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

package/dist/order-payment-in-review-x4gdLFHZ.js

@@ -0,0 +1,65 @@
+import { money } from "./money-DtGOtDri.js";
+import { useStorefrontLocale, useStorefrontText } from "./storefront-language-DrMjVbmk.js";
+import { Link, useLocation, useRevalidator } from "react-router";
+import { useEffect, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+// src/order-payment-in-review.tsx
+const CONFIRMATION_POLL_MS = 3e3;
+const CONFIRMATION_TIMEOUT_MS = 6e4;
+const MESSAGES = {
+	awaitingProvider: "Estamos confirmando tu pago de {value0}. Esto puede tardar unos segundos.",
+	awaitingCapture: "Recibimos tu pago de {value0}. La tienda lo confirmará en breve.",
+	receiptInReview: "Recibimos tu comprobante por {value0}. La tienda lo revisará en breve."
+};
+function OrderPaymentInReview({ payment, currency }) {
+	const storefrontTranslate = useStorefrontText();
+	const { locale } = useStorefrontLocale();
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col gap-2 rounded-lg border p-5",
+		role: "status",
+		children: [
+			/* @__PURE__ */ jsx("p", {
+				className: "font-medium",
+				children: storefrontTranslate("Pago en confirmación")
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "text-sm text-muted-foreground",
+				children: storefrontTranslate(MESSAGES[payment.kind], { value0: money(payment.amount, currency, locale) })
+			}),
+			payment.kind === "awaitingProvider" ? /* @__PURE__ */ jsx(ProviderConfirmation, {}) : null
+		]
+	});
+}
+function ProviderConfirmation() {
+	const storefrontTranslate = useStorefrontText();
+	const revalidator = useRevalidator();
+	const location = useLocation();
+	const [timedOut, setTimedOut] = useState(false);
+	useEffect(() => {
+		const poll = window.setInterval(() => {
+			revalidator.revalidate();
+		}, CONFIRMATION_POLL_MS);
+		const timeout = window.setTimeout(() => {
+			window.clearInterval(poll);
+			setTimedOut(true);
+		}, CONFIRMATION_TIMEOUT_MS);
+		return () => {
+			window.clearInterval(poll);
+			window.clearTimeout(timeout);
+		};
+	}, [revalidator.revalidate]);
+	if (!timedOut) return null;
+	return /* @__PURE__ */ jsxs("p", {
+		className: "text-sm",
+		children: [
+			storefrontTranslate("Aún no recibimos la confirmación. Si ya completaste el pago, no lo repitas: te avisaremos cuando se confirme."),
+			" ",
+			/* @__PURE__ */ jsx(Link, {
+				to: location.pathname,
+				className: "underline",
+				children: storefrontTranslate("Ver opciones de pago")
+			})
+		]
+	});
+}
+export { OrderPaymentInReview };

package/dist/order-payment-in-review.d.ts

@@ -0,0 +1,5 @@
+import { OrderPaymentReview } from "./order-status.js";
+export declare function OrderPaymentInReview({ payment, currency }: {
+  payment: OrderPaymentReview;
+  currency: string;
+}): import("react").JSX.Element;

package/dist/order-status-BJXLJwxq.js

@@ -0,0 +1,162 @@
+import { orderAnalytics } from "./analytics/events-Dt81tIp1.js";
+import { text } from "./form-BtQcbXlJ.js";
+import { found, store } from "./store-8Q-_LFrQ.js";
+import { worker } from "./worker-CNi-gzCu.js";
+import { PAYMENT_RETURN_CONFIRMING, PAYMENT_RETURN_PARAM } from "./payment-return-5cjypwIw.js";
+import { data, redirect } from "react-router";
+import { ApiError, AuthenticateOrderPaymentInputSchema } from "@ecomiq/core";
+// src/order-status.ts
+function hasOrderPaymentContinuation(payment) {
+	return payment !== void 0 && payment !== null && !payment.isCaptured && payment.providerId !== "manual" && payment.actionKind !== "none";
+}
+const PROGRESS = [
+	{
+		key: "confirmed",
+		label: "Confirmado"
+	},
+	{
+		key: "shipped",
+		label: "Enviado"
+	},
+	{
+		key: "outForDelivery",
+		label: "En reparto"
+	},
+	{
+		key: "delivered",
+		label: "Entregado"
+	}
+];
+const TITLES = {
+	pending: "Pedido recibido",
+	confirmed: "Pedido confirmado",
+	shipped: "Pedido enviado",
+	outForDelivery: "En reparto",
+	delivered: "Pedido entregado",
+	cancelled: "Pedido cancelado"
+};
+function orderProgress(step) {
+	const current = PROGRESS.findIndex((item) => item.key === step);
+	return PROGRESS.map((item, index) => ({
+		...item,
+		done: index <= current,
+		current: index === current
+	}));
+}
+function orderStepTitle(step) {
+	return TITLES[step];
+}
+function returnsFromPaymentProvider(context) {
+	const { requestUrl } = context.get(worker);
+	if (requestUrl === void 0) return false;
+	return new URL(requestUrl).searchParams.get(PAYMENT_RETURN_PARAM) === PAYMENT_RETURN_CONFIRMING;
+}
+async function loadOrderStatus(context, token) {
+	const status = await found(store(context).getOrderStatus(token), (code) => code < 500);
+	const methods = status.paymentMethods.filter((method) => method.isActive).sort((a, b) => a.sortOrder - b.sortOrder);
+	const settings = await store(context).getSettings();
+	let paymentInReview = status.paymentInReview;
+	if (paymentInReview === null && status.balanceDue > 0 && returnsFromPaymentProvider(context)) paymentInReview = {
+		kind: "awaitingProvider",
+		amount: status.balanceDue
+	};
+	return {
+		token,
+		order: status.order,
+		step: status.step,
+		balanceDue: status.balanceDue,
+		methods,
+		pendingPayment: status.pendingPayment,
+		paymentInReview,
+		timeZone: settings.store.timeZone,
+		locale: `${settings.store.language}-${settings.store.countryCode}`,
+		analytics: orderAnalytics(status.order, status.balanceDue <= 0 && status.step !== "cancelled")
+	};
+}
+function failure(message) {
+	return data({
+		ok: false,
+		message
+	}, { status: 400 });
+}
+const ORDER_PAYMENT_CONFLICTS = {
+	"Payments.ProviderOperationInProgress": "Ya iniciaste un pago para este pedido. Complétalo con el mismo medio de pago o espera a que venza para elegir otro.",
+	"Payments.ProviderOutcomePending": "Ya iniciaste un pago para este pedido. Complétalo con el mismo medio de pago o espera a que venza para elegir otro.",
+	"Payments.PaymentProjectionPending": "Estamos registrando un pago anterior de este pedido. Actualiza la página en unos minutos.",
+	"Orders.NoBalanceDue": "Este pedido ya no tiene saldo pendiente."
+};
+async function orderPaymentAction(request, context, token) {
+	const form = await request.formData();
+	if (text(form, "intent") === "authenticate") {
+		let authentication3DS;
+		try {
+			authentication3DS = JSON.parse(text(form, "authentication3DS"));
+		} catch {
+			return failure("No pudimos validar la autenticación del pago.");
+		}
+		const input = AuthenticateOrderPaymentInputSchema.safeParse({
+			token: text(form, "token"),
+			deviceSessionId: text(form, "deviceSessionId"),
+			authentication3DS
+		});
+		const transactionId = text(form, "transactionId");
+		if (!input.success || !transactionId) return failure("No pudimos validar la autenticación del pago.");
+		try {
+			const payment = await store(context).authenticateOrderPayment(token, transactionId, input.data);
+			return {
+				ok: true,
+				message: payment.isCaptured ? "Recibimos tu pago." : "Estamos confirmando tu pago.",
+				payment,
+				authenticatedTransactionId: payment.actionKind === "threeDS" ? void 0 : transactionId
+			};
+		} catch (error) {
+			if (error instanceof ApiError && error.status === 404) throw data(null, { status: 404 });
+			return failure("No pudimos confirmar la autenticación. Consulta el estado del pedido antes de intentar nuevamente.");
+		}
+	}
+	const method = text(form, "method");
+	if (!method) return failure("Elige un medio de pago.");
+	try {
+		const file = form.get("receipt") ?? form.get("file");
+		const client = store(context);
+		let payment;
+		if (file instanceof File && file.size > 0) {
+			if (file.size > 5242880) return failure("El comprobante debe pesar como máximo 5 MB.");
+			if (![
+				"image/jpeg",
+				"image/png",
+				"image/webp"
+			].includes(file.type)) return failure("Adjunta un comprobante JPG, PNG o WebP.");
+			payment = await client.uploadOrderPaymentReceipt(token, {
+				paymentMethodCode: method,
+				file
+			});
+		} else payment = await client.startOrderPayment(token, {
+			paymentMethodCode: method,
+			token: text(form, "token") || void 0,
+			providerPaymentMethodId: text(form, "providerPaymentMethodId") || void 0,
+			deviceSessionId: text(form, "deviceSessionId") || void 0
+		});
+		if (payment.actionKind === "redirect" && payment.actionUrl) return redirect(payment.actionUrl);
+		let message = "Continúa para completar el pago.";
+		if (payment.isCaptured) message = "Recibimos tu pago.";
+		else if (payment.receiptUrl) message = "Recibimos tu comprobante. Te avisaremos cuando confirmemos el pago.";
+		else if (payment.providerId === "manual" || payment.actionKind === "none") message = "Registramos tu pago. Te avisaremos cuando lo confirmemos.";
+		return {
+			ok: true,
+			message,
+			payment,
+			method
+		};
+	} catch (error) {
+		if (error instanceof ApiError && error.status === 404) throw data(null, { status: 404 });
+		if (error instanceof ApiError && error.status === 409) {
+			let message = "Ya hay un pago registrado para este pedido.";
+			if (error.code !== void 0) message = ORDER_PAYMENT_CONFLICTS[error.code] ?? message;
+			return failure(message);
+		}
+		if (error instanceof ApiError && error.status >= 400 && error.status < 500) return failure(error.message);
+		return failure("No pudimos iniciar el pago. Intenta de nuevo.");
+	}
+}
+export { hasOrderPaymentContinuation, loadOrderStatus, orderPaymentAction, orderProgress, orderStepTitle };

package/dist/order-status.d.ts

@@ -0,0 +1,89 @@
+import { PageAnalytics } from "./analytics/events.js";
+import { RouterContextProvider } from "react-router";
+import { CustomerOrderDetail, OrderPaymentInReview, OrderPaymentMethod, OrderPaymentStart, OrderStep } from "@ecomiq/core";
+export type OrderPaymentReview = OrderPaymentInReview | {
+  kind: "awaitingProvider";
+  amount: number;
+};
+export type OrderStatusData = {
+  token: string;
+  order: CustomerOrderDetail;
+  step: OrderStep;
+  balanceDue: number;
+  methods: OrderPaymentMethod[];
+  pendingPayment: OrderPaymentStart | null;
+  paymentInReview: OrderPaymentReview | null;
+  timeZone: string;
+  locale: string;
+  analytics: PageAnalytics;
+};
+export type OrderPaymentActionData = {
+  ok: boolean;
+  message: string;
+  payment?: OrderPaymentStart;
+  method?: string;
+  authenticatedTransactionId?: string;
+};
+export type OrderProgressStep = {
+  key: OrderStep;
+  label: string;
+  done: boolean;
+  current: boolean;
+};
+export declare function hasOrderPaymentContinuation(payment: OrderPaymentStart | null | undefined): payment is OrderPaymentStart;
+export declare function orderProgress(step: OrderStep): OrderProgressStep[];
+export declare function orderStepTitle(step: OrderStep): string;
+export declare function loadOrderStatus(context: Readonly<RouterContextProvider>, token: string): Promise<OrderStatusData>;
+export declare function orderPaymentAction(request: Request, context: Readonly<RouterContextProvider>, token: string): Promise<import("react-router").UNSAFE_DataWithResponseInit<OrderPaymentActionData> | Response | {
+  ok: true;
+  message: string;
+  payment: {
+    actionUrl: string | null;
+    isCaptured: boolean;
+    transactionId: string | null;
+    externalId: string | null;
+    actionKind: "embedded" | "none" | "qrCode" | "redirect" | "threeDS" | "voucher";
+    providerId: string | null;
+    publicConfiguration: {
+      publishableKey?: string | undefined;
+      publicKey?: string | undefined;
+    };
+    clientSecret: string | null;
+    qrCode: string | null;
+    receiptUrl: string | null;
+    expiresAt: string | null;
+    paymentMethodCode: string | null;
+    amount: number | null;
+    currencyCode: string | null;
+    voucherCode: string | null;
+    qrImageUrl: string | null;
+  };
+  authenticatedTransactionId: string | undefined;
+  method?: undefined;
+} | {
+  authenticatedTransactionId?: undefined;
+  ok: true;
+  message: string;
+  payment: {
+    actionUrl: string | null;
+    isCaptured: boolean;
+    transactionId: string | null;
+    externalId: string | null;
+    actionKind: "embedded" | "none" | "qrCode" | "redirect" | "threeDS" | "voucher";
+    providerId: string | null;
+    publicConfiguration: {
+      publishableKey?: string | undefined;
+      publicKey?: string | undefined;
+    };
+    clientSecret: string | null;
+    qrCode: string | null;
+    receiptUrl: string | null;
+    expiresAt: string | null;
+    paymentMethodCode: string | null;
+    amount: number | null;
+    currencyCode: string | null;
+    voucherCode: string | null;
+    qrImageUrl: string | null;
+  };
+  method: string;
+}>;

package/dist/order-view-9IlBg5AF.js

@@ -0,0 +1,62 @@
+// src/order-view.ts
+const STEP_LABELS = {
+	pending: "Recibido",
+	confirmed: "Confirmado",
+	shipped: "Enviado",
+	outForDelivery: "En reparto",
+	delivered: "Entregado",
+	cancelled: "Cancelado"
+};
+const STATUS_STEPS = {
+	new: "pending",
+	pendingToConfirm: "pending",
+	none: "pending",
+	confirmed: "confirmed",
+	inProgress: "confirmed",
+	invoiced: "confirmed",
+	readyToPickUp: "confirmed",
+	inTransit: "shipped",
+	pendingToDeliveredToClient: "outForDelivery",
+	delivered: "delivered",
+	partialDelivered: "delivered",
+	returned: "delivered",
+	partialReturned: "delivered",
+	closed: "delivered",
+	cancelled: "cancelled",
+	partialCancelled: "cancelled",
+	invalid: "cancelled"
+};
+const PAYMENT_STATUS_LABELS = {
+	pending: "Pendiente",
+	authorized: "Autorizado",
+	captured: "Pagado",
+	failed: "Rechazado",
+	cancelled: "Anulado",
+	refunded: "Reembolsado"
+};
+function camel(value) {
+	return value.charAt(0).toLowerCase() + value.slice(1);
+}
+/** The step the buyer sees for an order or item; an older API sends only the status. */
+function orderStepOf(value) {
+	return value.step ?? STATUS_STEPS[camel(value.status.trim())] ?? "pending";
+}
+function orderStepLabel(step) {
+	return STEP_LABELS[step];
+}
+/** "Visa •••• 4242" for cards, otherwise the payment method name. */
+function paymentLabel(payment) {
+	const brand = payment.cardBrand?.trim() ?? "";
+	const last4 = payment.cardLast4?.trim() ?? "";
+	if (last4 !== "") return `${brand || payment.paymentMethod} •••• ${last4}`;
+	return brand || payment.paymentMethod;
+}
+function paymentStatusLabel(payment) {
+	if (payment.paymentStatus === null) return null;
+	return PAYMENT_STATUS_LABELS[camel(payment.paymentStatus)] ?? null;
+}
+/** The payment to preview in a list: the first one that went through, else the latest. */
+function mainPayment(payments) {
+	return payments.find((payment) => payment.paymentStatus !== null && ["captured", "authorized"].includes(camel(payment.paymentStatus))) ?? payments.at(-1) ?? null;
+}
+export { mainPayment, orderStepLabel, orderStepOf, paymentLabel, paymentStatusLabel };

package/dist/order-view.d.ts

@@ -0,0 +1,12 @@
+import { CustomerOrderPayment, OrderStep } from "@ecomiq/core";
+/** The step the buyer sees for an order or item; an older API sends only the status. */
+export declare function orderStepOf(value: {
+  step?: OrderStep;
+  status: string;
+}): OrderStep;
+export declare function orderStepLabel(step: OrderStep): string;
+/** "Visa •••• 4242" for cards, otherwise the payment method name. */
+export declare function paymentLabel(payment: CustomerOrderPayment): string;
+export declare function paymentStatusLabel(payment: CustomerOrderPayment): string | null;
+/** The payment to preview in a list: the first one that went through, else the latest. */
+export declare function mainPayment(payments: CustomerOrderPayment[]): CustomerOrderPayment | null;

package/dist/page-action-Ctkf4xC6.js

@@ -0,0 +1,7 @@
+import { useLocation } from "react-router";
+// src/page-action.ts
+function usePageAction(path) {
+	const location = useLocation();
+	return location.pathname === path ? `${path}${location.search}` : path;
+}
+export { usePageAction };