@ecomiq/storefront 2.1.4 → 3.0.1

package/dist/sections-CNUMWTF_.js

@@ -0,0 +1,77 @@
+import "./source-marker-DhqSkW7n.js";
+import { store } from "./store-8Q-_LFrQ.js";
+import { data, useLoaderData } from "react-router";
+import { Suspense, createElement, use } from "react";
+// src/sections.ts
+const SECTIONS = "ecomiqSections";
+function canonical(value) {
+	if (Array.isArray(value)) return value.map(canonical);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]));
+}
+function sectionKey(section, props) {
+	const sourced = String(props["data-ecomiq-sources"] ?? "").split(" ");
+	const own = Object.entries(props).filter(([key, value]) => key !== "children" && !key.startsWith("data-") && !sourced.includes(key) && value !== void 0);
+	return `${section}:${JSON.stringify(canonical(Object.fromEntries(own)))}`;
+}
+function loadSections(args, entries) {
+	const client = store(args.context);
+	const unique = new Map(entries.map((entry) => [sectionKey(entry.section, entry.props), entry]));
+	return Object.fromEntries([...unique].map(([key, entry]) => {
+		return [key, Promise.resolve().then(() => entry.load(entry.props, {
+			...args,
+			client
+		})).catch((error) => {
+			console.error("[ecomiq] section load failed", entry.section, error);
+			return null;
+		})];
+	}));
+}
+function withSectionBoundary(Component) {
+	return function SectionBoundary(props) {
+		const fallback = createElement("div", {
+			"aria-hidden": true,
+			style: { minHeight: "24rem" }
+		});
+		return createElement(Suspense, { fallback }, createElement(Component, props));
+	};
+}
+function withResponseInit(value) {
+	return typeof value === "object" && value !== null && value.type === "DataWithResponseInit";
+}
+function plain(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function withSections(result, sections, extra = {}) {
+	if (result instanceof Response) return result;
+	if (withResponseInit(result)) return data(withSections(result.data, sections, extra), result.init ?? void 0);
+	if (result === void 0 || result === null) return {
+		...extra,
+		[SECTIONS]: sections
+	};
+	if (!plain(result)) return result;
+	const own = result[SECTIONS] ?? {};
+	return {
+		...result,
+		...extra,
+		[SECTIONS]: {
+			...own,
+			...sections
+		}
+	};
+}
+function loadedSections(loaded) {
+	if (!plain(loaded)) return void 0;
+	const own = loaded[SECTIONS];
+	if (own !== void 0) return own;
+	const nested = loaded.data;
+	return plain(nested) ? nested[SECTIONS] : void 0;
+}
+function useSection(load, props) {
+	const loaded = useLoaderData();
+	const section = load.section;
+	if (section === void 0) return void 0;
+	const value = loadedSections(loaded)?.[sectionKey(section, props)];
+	return value instanceof Promise ? use(value) : value;
+}
+export { loadSections, sectionKey, useSection, withSectionBoundary, withSections };

package/dist/sections.d.ts

@@ -0,0 +1,19 @@
+import { LoaderFunctionArgs } from "react-router";
+import { StorefrontClient } from "@ecomiq/core";
+import { ComponentType } from "react";
+export type SectionLoadArgs = LoaderFunctionArgs & {
+  readonly client: StorefrontClient;
+};
+export type SectionEntry = {
+  readonly section: string;
+  readonly load: (props: never, args: SectionLoadArgs) => Promise<unknown>;
+  readonly props: object;
+};
+export type SectionData = {
+  readonly [key: string]: unknown;
+};
+export declare function sectionKey(section: string, props: object): string;
+export declare function loadSections(args: LoaderFunctionArgs, entries: readonly SectionEntry[]): SectionData;
+export declare function withSectionBoundary<Props extends object>(Component: ComponentType<Props>): ComponentType<Props>;
+export declare function withSections(result: unknown, sections: SectionData, extra?: object): unknown;
+export declare function useSection<Props extends object, Data>(load: (props: Props, args: SectionLoadArgs) => Promise<Data>, props: Props): Data | undefined;

package/dist/seo-GpDRhAAA.js

@@ -0,0 +1,78 @@
+import { store } from "./store-8Q-_LFrQ.js";
+import { absoluteUrl, canonicalOrigin } from "./urls-CpGQPxvf.js";
+// src/seo.ts
+const PRIVATE_PATHS = [
+	"/cart",
+	"/checkout",
+	"/account",
+	"/search"
+];
+const CACHE = "public, max-age=30";
+function escape(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+async function robots(request, context) {
+	const settings = await store(context).getSettings();
+	const lines = ["User-agent: *"];
+	if (settings.cms.settings.seo.robotsIndex) {
+		for (const path of PRIVATE_PATHS) lines.push(`Disallow: ${path}`);
+		lines.push("", `Sitemap: ${absoluteUrl(canonicalOrigin(request, settings), "/sitemap.xml")}`);
+	} else lines.push("Disallow: /");
+	return new Response(`${lines.join("\n")}\n`, { headers: {
+		"Content-Type": "text/plain; charset=utf-8",
+		"Cache-Control": CACHE
+	} });
+}
+function sitemapResponse(body) {
+	return new Response(`<?xml version="1.0" encoding="UTF-8"?>\n${body}\n`, { headers: {
+		"Content-Type": "application/xml; charset=utf-8",
+		"Cache-Control": CACHE
+	} });
+}
+async function sitemap(request, context) {
+	const pageParam = new URL(request.url).searchParams.get("page");
+	const pageNumber = pageParam === null ? 1 : Number(pageParam);
+	if (pageParam !== null && (!/^[1-9]\d*$/.test(pageParam) || !Number.isSafeInteger(pageNumber))) return new Response("Página inválida", { status: 400 });
+	const client = store(context);
+	const [settings, page] = await Promise.all([client.getSettings(), client.getSitemap(pageNumber)]);
+	if (pageNumber > page.totalPages) return new Response(null, { status: 404 });
+	const origin = canonicalOrigin(request, settings);
+	if (pageParam === null && page.totalPages > 1) return sitemapResponse(`<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${Array.from({ length: page.totalPages }, (_, index) => {
+		const url = new URL(absoluteUrl(origin, "/sitemap.xml"));
+		url.searchParams.set("page", String(index + 1));
+		return `<sitemap><loc>${escape(url.href)}</loc></sitemap>`;
+	}).join("\n")}\n</sitemapindex>`);
+	const items = [];
+	if (pageNumber === 1) {
+		items.push({
+			url: "/",
+			updatedOn: null
+		});
+		for (const cmsPage of settings.cms.pages) {
+			if (cmsPage.channel !== "storefront" || !cmsPage.hasPublishedVersion || cmsPage.slug === "home") continue;
+			items.push({
+				url: `/pages/${cmsPage.slug}`,
+				updatedOn: cmsPage.publishedOn ?? cmsPage.updatedOn
+			});
+		}
+	}
+	items.push(...page.items);
+	return sitemapResponse(`<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${items.map((item) => {
+		let entry = `<url><loc>${escape(absoluteUrl(origin, item.url))}</loc>`;
+		if (item.updatedOn !== null) entry += `<lastmod>${escape(item.updatedOn)}</lastmod>`;
+		return `${entry}</url>`;
+	}).join("\n")}\n</urlset>`);
+}
+async function seoResponse(request, context) {
+	if (request.method !== "GET" && request.method !== "HEAD") return null;
+	const path = new URL(request.url).pathname;
+	let response = null;
+	if (path === "/robots.txt") response = await robots(request, context);
+	if (path === "/sitemap.xml") response = await sitemap(request, context);
+	if (response === null || request.method === "GET") return response;
+	return new Response(null, {
+		status: response.status,
+		headers: response.headers
+	});
+}
+export { seoResponse };

package/dist/session-CKvmFJyg.js

@@ -0,0 +1,379 @@
+import { loadStorefrontTranslations, storefrontText } from "./storefront-text-D25ae1qf.js";
+import { captchaResponse } from "./captcha-DAqaIx8m.js";
+import { base64Url, customerCookies, customerSessionId, equalSecret } from "./customer-cookies-DHOgFAMV.js";
+import { safeNext } from "./form-BtQcbXlJ.js";
+import { PREVIEW_TOKEN } from "./preview-BiIBif3C.js";
+import { customerClientHeaders, customerCsrfTokenForRequest, rejectCrossOriginAction } from "./request-security-CRsRMgwj.js";
+import { store } from "./store-8Q-_LFrQ.js";
+import { requestUrl } from "./urls-CpGQPxvf.js";
+import { worker } from "./worker-CNi-gzCu.js";
+import { data, redirect } from "react-router";
+import { ApiError } from "@ecomiq/core";
+import { z } from "zod";
+// src/session.ts
+const currentRequests = /* @__PURE__ */ new WeakMap();
+const registrationRequests = /* @__PURE__ */ new WeakMap();
+const PRIVATE_HEADERS = {
+	"Cache-Control": "private, no-store",
+	"Referrer-Policy": "no-referrer"
+};
+const TransactionSchema = z.object({
+	state: z.string().min(1),
+	nonce: z.string().min(1),
+	verifier: z.string().min(43).max(128),
+	redirectUri: z.string().url(),
+	next: z.string(),
+	createdAt: z.number(),
+	loginMode: z.enum(["hosted", "storefront"]),
+	authorizationEndpoint: z.string().url(),
+	returnUrl: z.string(),
+	browserKey: z.string(),
+	email: z.string().default(""),
+	challengeId: z.string().optional(),
+	needsSecondFactor: z.boolean().default(false),
+	retryAt: z.number().default(0)
+});
+const ChallengeSchema = z.object({ challengeId: z.string().min(1) });
+const ChallengeErrorSchema = z.object({
+	message: z.string(),
+	needsSecondFactor: z.boolean().optional()
+});
+function validLoginTransaction(transaction, configuration, origin) {
+	if (Date.now() - transaction.createdAt > 6e5 || transaction.createdAt > Date.now() || transaction.redirectUri !== new URL("/account/callback", origin).href || transaction.redirectUri !== configuration.redirectUri || transaction.authorizationEndpoint !== configuration.authorizationEndpoint || transaction.loginMode !== configuration.loginMode) return false;
+	const authorize = new URL(transaction.returnUrl, configuration.authority);
+	return authorize.origin === new URL(configuration.authorizationEndpoint).origin && authorize.pathname === new URL(configuration.authorizationEndpoint).pathname && authorize.searchParams.get("client_id") === configuration.clientId && authorize.searchParams.get("scope") === configuration.scope;
+}
+async function loginFormData(transaction, configuration, context, error = null, status = 200, clearSession = false) {
+	let step = "email";
+	if (transaction.challengeId) step = "code";
+	if (transaction.needsSecondFactor) step = "secondFactor";
+	const cookies = customerCookies(context.get(worker).env);
+	const headers = new Headers(PRIVATE_HEADERS);
+	headers.append("Set-Cookie", await cookies.transaction.serialize(transaction));
+	if (clearSession) headers.append("Set-Cookie", await cookies.session.serialize("", { maxAge: 0 }));
+	return data({
+		step,
+		email: transaction.email,
+		captcha: configuration.captcha,
+		retryAt: transaction.retryAt,
+		error
+	}, {
+		status,
+		headers
+	});
+}
+async function customerCsrfToken(request, context) {
+	return customerCsrfTokenForRequest(request, context.get(worker).env);
+}
+function previewing(request, env) {
+	return env.ECOMIQ_PREVIEW === "1" && !/^\/account\/(login|callback)(\/|$)/.test(requestUrl(request).pathname);
+}
+async function readCustomer(request, context) {
+	const env = context.get(worker).env;
+	if (previewing(request, env)) return {
+		sessionId: PREVIEW_TOKEN,
+		name: "Ana"
+	};
+	const sessionId = await customerSessionId(request, env);
+	if (!sessionId) return null;
+	try {
+		const session = await store(context).getCustomerSession({ headers: { "X-Customer-Session": sessionId } });
+		if (Date.parse(session.expiresAt) <= Date.now()) return null;
+		return {
+			sessionId,
+			name: session.customer.firstName || session.customer.email
+		};
+	} catch (error) {
+		if (error instanceof ApiError && (error.status === 401 || error.status === 403)) return null;
+		throw error;
+	}
+}
+function customer(request, context) {
+	let pending = currentRequests.get(request);
+	if (!pending) {
+		pending = readCustomer(request, context);
+		currentRequests.set(request, pending);
+	}
+	return pending;
+}
+async function requireCustomer(request, context) {
+	const current = await customer(request, context);
+	if (current) {
+		await requireCustomerRegistration(request, context, current);
+		return current;
+	}
+	const url = requestUrl(request);
+	throw redirect(`/account/login?next=${encodeURIComponent(url.pathname + url.search)}`, { headers: PRIVATE_HEADERS });
+}
+/** Loads customer data alongside the session and registration checks and returns it only after both pass. */
+async function requireCustomerWith(request, context, load) {
+	const env = context.get(worker).env;
+	const sessionId = previewing(request, env) ? PREVIEW_TOKEN : await customerSessionId(request, env);
+	if (!sessionId) return load(customerHeaders(await requireCustomer(request, context)));
+	const headers = customerHeaders({
+		sessionId,
+		name: ""
+	});
+	if (sessionId !== "ecomiq-editor-preview" && !registrationRequests.has(request)) {
+		const registration = store(context).getCustomerRegistration(headers);
+		registration.catch(() => void 0);
+		registrationRequests.set(request, registration);
+	}
+	const pending = load(headers);
+	pending.catch(() => void 0);
+	await requireCustomer(request, context);
+	return pending;
+}
+/** Enforces profile completion for authenticated account and checkout requests. */
+async function requireCustomerRegistration(request, context, current) {
+	if (current.sessionId === "ecomiq-editor-preview") return;
+	let pending = registrationRequests.get(request);
+	if (!pending) {
+		pending = store(context).getCustomerRegistration(customerHeaders(current));
+		registrationRequests.set(request, pending);
+	}
+	if ((await pending).requiresCompletion) {
+		const url = requestUrl(request);
+		throw redirect(`/account/register?next=${encodeURIComponent(safeNext(url.pathname + url.search))}`, {
+			status: 303,
+			headers: PRIVATE_HEADERS
+		});
+	}
+}
+function customerHeaders(current) {
+	return { headers: { "X-Customer-Session": current.sessionId } };
+}
+function identityTransportUrl(endpoint, context) {
+	const transportUrl = context.get(worker).env.ECOMIQ_AUTH_URL;
+	if (!transportUrl) return endpoint;
+	const transport = new URL(transportUrl);
+	if (!["http:", "https:"].includes(transport.protocol) || transport.username || transport.password || transport.pathname !== "/" || transport.search || transport.hash) throw new Error("ECOMIQ_AUTH_URL debe ser el origen de Identity.");
+	const target = new URL(endpoint);
+	target.protocol = transport.protocol;
+	target.host = transport.host;
+	return target.href;
+}
+function randomSecret() {
+	return base64Url(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(32)));
+}
+async function loginFailure(message, status, headers, context) {
+	const language = (await store(context).getSettings().catch(() => null))?.store.language ?? "es";
+	const translations = await loadStorefrontTranslations(language);
+	const t = (source) => storefrontText(translations, source);
+	headers.set("Content-Type", "text/html; charset=utf-8");
+	headers.set("Content-Security-Policy", "default-src 'none'; base-uri 'none'; frame-ancestors 'none'");
+	return new Response(`<!doctype html><html lang="${language}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>${t("No pudimos iniciar sesión")}</title></head><body><main><h1>${t("No pudimos iniciar sesión")}</h1><p>${t(message)}</p><p><a href="/account/login">${t("Intentar de nuevo")}</a></p><p><a href="/">${t("Volver a la tienda")}</a></p></main></body></html>`, {
+		status,
+		headers
+	});
+}
+async function startCustomerLogin(request, context) {
+	const url = new URL(request.url);
+	const next = safeNext(url.searchParams.get("next"));
+	const current = await customer(request, context);
+	if (current) {
+		if ((await store(context).getCustomerRegistration(customerHeaders(current))).requiresCompletion) return redirect(`/account/register?next=${encodeURIComponent(next)}`, { headers: PRIVATE_HEADERS });
+		return redirect(next, { headers: PRIVATE_HEADERS });
+	}
+	const clearSession = await customerSessionId(request, context.get(worker).env) !== null;
+	const configuration = await store(context).upsertCustomerAuthConfiguration(url.origin);
+	const redirectUri = new URL("/account/callback", url.origin).href;
+	if (configuration.redirectUri !== redirectUri) throw new Error("El dominio de acceso no corresponde a esta tienda.");
+	const saved = TransactionSchema.safeParse(await customerCookies(context.get(worker).env).transaction.parse(request.headers.get("Cookie")));
+	if (configuration.loginMode === "storefront" && saved.success && validLoginTransaction(saved.data, configuration, url.origin)) return loginFormData(saved.data, configuration, context, null, 200, clearSession);
+	const verifier = randomSecret();
+	const challenge = base64Url(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier))));
+	const state = randomSecret();
+	const nonce = randomSecret();
+	const authorize = new URL(configuration.authorizationEndpoint);
+	authorize.search = new URLSearchParams({
+		client_id: configuration.clientId,
+		response_type: "code",
+		redirect_uri: redirectUri,
+		scope: configuration.scope,
+		code_challenge: challenge,
+		code_challenge_method: "S256",
+		state,
+		nonce
+	}).toString();
+	const transaction = {
+		state,
+		nonce,
+		verifier,
+		redirectUri,
+		next,
+		createdAt: Date.now(),
+		loginMode: configuration.loginMode,
+		authorizationEndpoint: configuration.authorizationEndpoint,
+		returnUrl: authorize.pathname + authorize.search,
+		browserKey: randomSecret(),
+		email: "",
+		needsSecondFactor: false,
+		retryAt: 0
+	};
+	if (configuration.loginMode === "storefront") return loginFormData(transaction, configuration, context, null, 200, clearSession);
+	const cookies = customerCookies(context.get(worker).env);
+	const headers = new Headers(PRIVATE_HEADERS);
+	headers.append("Set-Cookie", await cookies.transaction.serialize(transaction));
+	if (clearSession) headers.append("Set-Cookie", await cookies.session.serialize("", { maxAge: 0 }));
+	return redirect(authorize.href, { headers });
+}
+/** Receives only browser form fields; the signed transaction owns all OAuth values. */
+async function submitCustomerLogin(request, context) {
+	const rejected = rejectCrossOriginAction(request);
+	if (rejected) return rejected;
+	const origin = new URL(request.url).origin;
+	const configuration = await store(context).upsertCustomerAuthConfiguration(origin);
+	const cookies = customerCookies(context.get(worker).env);
+	const saved = TransactionSchema.safeParse(await cookies.transaction.parse(request.headers.get("Cookie")));
+	if (configuration.loginMode !== "storefront" || !saved.success || !validLoginTransaction(saved.data, configuration, origin)) return redirect("/account/login", {
+		status: 303,
+		headers: {
+			...PRIVATE_HEADERS,
+			"Set-Cookie": await cookies.transaction.serialize("", { maxAge: 0 })
+		}
+	});
+	const transaction = saved.data;
+	const form = await request.formData();
+	const field = (name) => {
+		const value = form.get(name);
+		return typeof value === "string" ? value.trim() : "";
+	};
+	const intent = field("intent");
+	if (intent === "reset") {
+		transaction.email = "";
+		transaction.challengeId = void 0;
+		transaction.needsSecondFactor = false;
+		return loginFormData(transaction, configuration, context);
+	}
+	if (intent === "send" || intent === "resend") {
+		if (transaction.retryAt > Date.now()) return loginFormData(transaction, configuration, context, "Espera un minuto antes de solicitar otro código.", 429);
+		const email = intent === "resend" ? transaction.email : field("email");
+		if (!z.string().email().max(254).safeParse(email).success) return loginFormData(transaction, configuration, context, "Ingresa un correo electrónico válido.", 400);
+		if (!configuration.captcha.isConfigured) return loginFormData(transaction, configuration, context, "La tienda debe completar la configuración de verificación. Intenta más tarde.", 503);
+		const captchaToken = captchaResponse(form, configuration.captcha.provider);
+		if (configuration.captcha.provider !== "off" && !captchaToken) return loginFormData(transaction, configuration, context, "Completa la verificación antes de continuar.", 400);
+		try {
+			const challengeUrl = identityTransportUrl(new URL("/v1/customer-auth/challenges", configuration.authority).href, context);
+			const client = await customerClientHeaders(request, context.get(worker).env, new URL(challengeUrl));
+			const response = await fetch(challengeUrl, {
+				method: "POST",
+				redirect: "manual",
+				headers: {
+					"Content-Type": "application/json",
+					...client
+				},
+				body: JSON.stringify({
+					returnUrl: transaction.returnUrl,
+					browserKey: transaction.browserKey,
+					email,
+					captchaToken: captchaToken || void 0
+				})
+			});
+			if (!response.ok) return loginIdentityError(response, transaction, configuration, context);
+			const challenge = ChallengeSchema.parse(await response.json());
+			transaction.email = email;
+			transaction.challengeId = challenge.challengeId;
+			transaction.needsSecondFactor = false;
+			transaction.retryAt = Date.now() + 6e4;
+			return loginFormData(transaction, configuration, context);
+		} catch (error) {
+			console.error("[ecomiq] customer login code failed", error);
+			return loginFormData(transaction, configuration, context, "No pudimos enviar el código. Intenta de nuevo en unos minutos.", 503);
+		}
+	}
+	if (intent !== "verify" || !transaction.challengeId) return loginFormData(transaction, configuration, context, "Solicita un código para continuar.", 400);
+	const code = field("code");
+	const secondFactor = field("secondFactor");
+	if (!transaction.needsSecondFactor && !/^\d{6}$/.test(code)) return loginFormData(transaction, configuration, context, "Ingresa el código de seis dígitos que enviamos a tu correo.", 400);
+	if (transaction.needsSecondFactor && !secondFactor) return loginFormData(transaction, configuration, context, "Ingresa el código de tu aplicación de autenticación o uno de recuperación.", 400);
+	try {
+		const authorize = new URL(transaction.returnUrl, configuration.authority);
+		const authorizeUrl = identityTransportUrl(transaction.authorizationEndpoint, context);
+		const client = await customerClientHeaders(request, context.get(worker).env, new URL(authorizeUrl));
+		const response = await fetch(authorizeUrl, {
+			method: "POST",
+			redirect: "manual",
+			headers: {
+				...client,
+				"Content-Type": "application/x-www-form-urlencoded",
+				"X-Customer-Challenge": transaction.challengeId,
+				"X-Customer-Browser-Key": transaction.browserKey,
+				"X-Customer-Code": code,
+				"X-Customer-Second-Factor": secondFactor
+			},
+			body: authorize.searchParams
+		});
+		if (response.status !== 302) return loginIdentityError(response, transaction, configuration, context);
+		const location = response.headers.get("Location");
+		if (!location) throw new Error("Missing customer callback");
+		const callback = new URL(location);
+		const expected = new URL(transaction.redirectUri);
+		if (callback.origin !== expected.origin || callback.pathname !== expected.pathname || callback.hash || !equalSecret(callback.searchParams.get("state") ?? "", transaction.state)) throw new Error("Invalid customer callback");
+		return completeCustomerLogin(new Request(callback, { headers: { Cookie: request.headers.get("Cookie") ?? "" } }), context);
+	} catch (error) {
+		console.error("[ecomiq] customer login verification failed", error);
+		return loginFormData(transaction, configuration, context, "No pudimos completar el acceso. Intenta de nuevo en unos minutos.", 503);
+	}
+}
+async function loginIdentityError(response, transaction, configuration, context) {
+	const error = ChallengeErrorSchema.safeParse(await response.json().catch(() => null));
+	let message = "No pudimos completar el acceso. Intenta de nuevo en unos minutos.";
+	if (error.success && response.status < 500) {
+		message = error.data.message;
+		if (error.data.needsSecondFactor) transaction.needsSecondFactor = true;
+	}
+	if (response.status === 429) transaction.retryAt = Date.now() + 6e4;
+	const status = response.status >= 400 && response.status < 500 ? response.status : 503;
+	return loginFormData(transaction, configuration, context, message, status);
+}
+async function completeCustomerLogin(request, context) {
+	const url = new URL(request.url);
+	const cookies = customerCookies(context.get(worker).env);
+	const transaction = TransactionSchema.safeParse(await cookies.transaction.parse(request.headers.get("Cookie")));
+	const headers = new Headers(PRIVATE_HEADERS);
+	headers.append("Set-Cookie", await cookies.transaction.serialize("", { maxAge: 0 }));
+	if (!transaction.success || !equalSecret(url.searchParams.get("state") ?? "", transaction.data.state) || Date.now() - transaction.data.createdAt > 6e5 || transaction.data.createdAt > Date.now() || transaction.data.redirectUri !== new URL("/account/callback", url.origin).href) return loginFailure("El acceso venció o no corresponde a esta tienda. Vuelve a iniciar sesión.", 400, headers, context);
+	const code = url.searchParams.get("code");
+	if (url.searchParams.has("error") || !code) return loginFailure("No se completó el acceso. Vuelve a iniciar sesión desde la tienda.", 400, headers, context);
+	try {
+		const session = await store(context).createCustomerSession({
+			code,
+			codeVerifier: transaction.data.verifier,
+			redirectUri: transaction.data.redirectUri,
+			nonce: transaction.data.nonce
+		});
+		headers.append("Set-Cookie", await cookies.session.serialize(session.sessionId, { expires: new Date(session.expiresAt) }));
+		const next = safeNext(transaction.data.next);
+		if ((await store(context).getCustomerRegistration({ headers: { "X-Customer-Session": session.sessionId } })).requiresCompletion) return redirect(`/account/register?next=${encodeURIComponent(next)}`, { headers });
+		return redirect(next, { headers });
+	} catch (error) {
+		if (error instanceof ApiError && error.status >= 400 && error.status < 500) return loginFailure("No pudimos habilitar tu cuenta en esta tienda. Vuelve a iniciar sesión o contacta a la tienda.", error.status, headers, context);
+		return loginFailure("No pudimos completar el acceso. Intenta iniciar sesión de nuevo en unos minutos.", 503, headers, context);
+	}
+}
+async function logout(request, context) {
+	const env = context.get(worker).env;
+	const origin = new URL(request.url).origin;
+	const configuration = await store(context).upsertCustomerAuthConfiguration(origin);
+	if (configuration.redirectUri !== new URL("/account/callback", origin).href) throw new Error("El dominio de salida no corresponde a esta tienda.");
+	const storeId = /^ecomiq-customer-(\d+)$/.exec(configuration.clientId)?.[1];
+	if (!storeId) throw new Error("La configuración de salida de la tienda no es válida.");
+	const sessionId = await customerSessionId(request, env);
+	if (sessionId) try {
+		await store(context).deleteCustomerSession({ headers: { "X-Customer-Session": sessionId } });
+	} catch (error) {
+		if (!(error instanceof ApiError) || error.status !== 401 && error.status !== 404) throw error;
+	}
+	const hostedLogout = new URL("/customer/logout", configuration.authority);
+	hostedLogout.searchParams.set("storeId", storeId);
+	hostedLogout.searchParams.set("origin", origin);
+	return redirect(hostedLogout.href, {
+		status: 303,
+		headers: {
+			...PRIVATE_HEADERS,
+			"Set-Cookie": await customerCookies(env).session.serialize("", { maxAge: 0 })
+		}
+	});
+}
+export { completeCustomerLogin, customer, customerCsrfToken, customerHeaders, logout, requireCustomer, requireCustomerRegistration, requireCustomerWith, startCustomerLogin, submitCustomerLogin };

package/dist/session.d.ts

@@ -0,0 +1,24 @@
+import { RouterContextProvider, data } from "react-router";
+import { CustomerAuthConfiguration, CustomerRequestOptions } from "@ecomiq/core";
+export type Customer = {
+  sessionId: string;
+  name: string;
+};
+export type CustomerLoginData = {
+  step: "email" | "code" | "secondFactor";
+  email: string;
+  captcha: CustomerAuthConfiguration["captcha"];
+  retryAt: number;
+  error: string | null;
+};
+export declare function customerCsrfToken(request: Request, context: Readonly<RouterContextProvider>): Promise<string>;
+export declare function customer(request: Request, context: Readonly<RouterContextProvider>): Promise<Customer | null>;
+export declare function requireCustomer(request: Request, context: Readonly<RouterContextProvider>): Promise<Customer>;
+/** Enforces profile completion for authenticated account and checkout requests. */
+export declare function requireCustomerRegistration(request: Request, context: Readonly<RouterContextProvider>, current: Customer): Promise<void>;
+export declare function customerHeaders(current: Customer): CustomerRequestOptions;
+export declare function startCustomerLogin(request: Request, context: Readonly<RouterContextProvider>): Promise<Response | ReturnType<typeof data<CustomerLoginData>>>;
+/** Receives only browser form fields; the signed transaction owns all OAuth values. */
+export declare function submitCustomerLogin(request: Request, context: Readonly<RouterContextProvider>): Promise<Response | ReturnType<typeof data<CustomerLoginData>>>;
+export declare function completeCustomerLogin(request: Request, context: Readonly<RouterContextProvider>): Promise<Response>;
+export declare function logout(request: Request, context: Readonly<RouterContextProvider>): Promise<Response>;

package/dist/settings-B0NO2A6Y.js

@@ -0,0 +1,78 @@
+// src/settings.ts
+function link(url, _label, reference) {
+	return reference ? {
+		url,
+		reference
+	} : url;
+}
+function select(value, _label, _options) {
+	return value;
+}
+const setting = {
+	text: (value, _label) => value,
+	richtext: (html, _label) => html,
+	image: (url, _label) => url,
+	video: (url, _label) => url,
+	link,
+	collection: (handle, _label) => handle,
+	category: (handle, _label) => handle,
+	product: (handle, _label) => handle,
+	products: (handles, _label) => handles,
+	number: (value, _label) => value,
+	range: (value, _label, _limits) => value,
+	toggle: (value, _label) => value,
+	color: (value, _label) => value,
+	select,
+	scheme: (id, _label) => id
+};
+function plain(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function section(defaults, props) {
+	const values = { ...defaults };
+	for (const key of Object.keys(defaults)) {
+		const value = props[key];
+		if (value === void 0) continue;
+		const base = defaults[key];
+		values[key] = plain(base) && plain(value) ? {
+			...base,
+			...value
+		} : value;
+	}
+	return values;
+}
+async function pickProducts(client, source) {
+	const limit = source.limit ?? 8;
+	if (source.products && source.products.length > 0) {
+		const slugs = source.products.slice(0, limit);
+		return (await client.getProducts({
+			slugs,
+			pageSize: slugs.length,
+			includeFilters: false
+		})).products;
+	}
+	if (source.collection) {
+		const collections = await client.getCollections().catch(() => []);
+		const slug = source.collection.trim().toLowerCase();
+		const collection = collections.find((item) => item.slug.toLowerCase() === slug);
+		if (collection === void 0) return [];
+		return (await client.getProducts({
+			collectionId: collection.id,
+			pageSize: limit,
+			sort: source.sort,
+			includeFilters: false
+		})).products;
+	}
+	if (source.category) return (await client.getProducts({
+		categories: [source.category],
+		pageSize: limit,
+		sort: source.sort,
+		includeFilters: false
+	})).products;
+	return (await client.getProducts({
+		pageSize: limit,
+		sort: source.sort,
+		includeFilters: false
+	})).products;
+}
+export { pickProducts, section, setting };