@ecomiq/storefront 2.1.3 → 3.0.0

package/dist/storefront-text.d.ts

@@ -0,0 +1,4 @@
+export type StorefrontTranslations = Readonly<Record<string, string>>;
+export type StorefrontTextValues = Readonly<Record<string, string | number | null | undefined>>;
+export declare function loadStorefrontTranslations(language: string): Promise<StorefrontTranslations>;
+export declare function storefrontText(translations: StorefrontTranslations, source: string, values?: StorefrontTextValues): string;

package/dist/stripe-dialog-Ev9s3Z62.js

@@ -0,0 +1,396 @@
+import { useStorefrontLocale, useStorefrontText } from "./storefront-language-DrMjVbmk.js";
+import { money } from "./money-DtGOtDri.js";
+import { PaymentDialogFrame } from "./payment-dialog-frame-B-Q_xQ94.js";
+import { confirmingPaymentUrl } from "./payment-return-5cjypwIw.js";
+import { useNavigate } from "react-router";
+import { useEffect, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+// src/stripe-dialog.tsx
+const STRIPE_WALLET_BY_METHOD = {
+	apple_pay: "applePay",
+	google_pay: "googlePay"
+};
+const WALLET_TITLES = {
+	applePay: "Pagar con Apple Pay",
+	googlePay: "Pagar con Google Pay"
+};
+const WALLET_UNAVAILABLE = {
+	applePay: "Apple Pay no está disponible en este dispositivo. Elige otro medio de pago.",
+	googlePay: "Google Pay no está disponible en este navegador. Elige otro medio de pago."
+};
+const ZERO_DECIMAL_CURRENCIES = /* @__PURE__ */ new Set([
+	"BIF",
+	"CLP",
+	"DJF",
+	"GNF",
+	"JPY",
+	"KMF",
+	"KRW",
+	"MGA",
+	"PYG",
+	"RWF",
+	"VND",
+	"VUV",
+	"XAF",
+	"XOF",
+	"XPF"
+]);
+const THREE_DECIMAL_CURRENCIES = /* @__PURE__ */ new Set([
+	"BHD",
+	"IQD",
+	"JOD",
+	"KWD",
+	"LYD",
+	"OMR",
+	"TND"
+]);
+const CONFIRMED_INTENT_STATUSES = /* @__PURE__ */ new Set([
+	"succeeded",
+	"processing",
+	"requires_capture"
+]);
+function findStripeWallet(method) {
+	if (method.providerId !== "stripe") return null;
+	return STRIPE_WALLET_BY_METHOD[method.code] ?? null;
+}
+function expressCheckoutPaymentMethods(wallet) {
+	let applePay = "never";
+	let googlePay = "never";
+	if (wallet === null || wallet === "applePay") applePay = "always";
+	if (wallet === null || wallet === "googlePay") googlePay = "always";
+	return {
+		applePay,
+		googlePay,
+		link: "never",
+		paypal: "never",
+		amazonPay: "never",
+		klarna: "never"
+	};
+}
+function useAvailableStripeWallets(methods, amount, currency) {
+	const { locale } = useStorefrontLocale();
+	const [wallets, setWallets] = useState(() => /* @__PURE__ */ new Set());
+	const publishableKey = methods.find((method) => findStripeWallet(method) !== null)?.publicConfiguration?.publishableKey;
+	useEffect(() => {
+		if (publishableKey === void 0) return;
+		const key = publishableKey;
+		let active = true;
+		let element;
+		const probe = document.createElement("div");
+		probe.setAttribute("aria-hidden", "true");
+		probe.style.cssText = "position:fixed;left:-10000px;top:0;width:320px;height:60px;";
+		async function detect() {
+			const client = await loadStripeClient(key, locale);
+			if (!active || client === null) return;
+			document.body.append(probe);
+			element = client.elements({
+				mode: "payment",
+				amount: toStripeMinorUnits(amount, currency),
+				currency: currency.toLowerCase(),
+				paymentMethodCreation: "manual",
+				paymentMethodTypes: ["card"]
+			}).create("expressCheckout", { paymentMethods: expressCheckoutPaymentMethods(null) });
+			element.on("ready", (event) => {
+				if (!active) return;
+				const available = /* @__PURE__ */ new Set();
+				if (event.availablePaymentMethods?.applePay === true) available.add("applePay");
+				if (event.availablePaymentMethods?.googlePay === true) available.add("googlePay");
+				setWallets(available);
+			});
+			element.mount(probe);
+		}
+		detect().catch(() => {
+			if (active) setWallets(/* @__PURE__ */ new Set());
+		});
+		return () => {
+			active = false;
+			element?.destroy();
+			probe.remove();
+		};
+	}, [
+		publishableKey,
+		amount,
+		currency,
+		locale
+	]);
+	return wallets;
+}
+function toStripeMinorUnits(amount, currency) {
+	const code = currency.toUpperCase();
+	let factor = 100;
+	if (ZERO_DECIMAL_CURRENCIES.has(code)) factor = 1;
+	if (THREE_DECIMAL_CURRENCIES.has(code)) factor = 1e3;
+	return Math.round(amount * factor);
+}
+function stripeLocale(locale) {
+	if (locale.startsWith("en")) return "en";
+	if (locale.startsWith("pt")) return "pt-BR";
+	return "es";
+}
+async function loadStripeClient(publishableKey, locale) {
+	const { loadStripe } = await import("@stripe/stripe-js/pure");
+	return loadStripe(publishableKey, { locale: stripeLocale(locale) });
+}
+function StripeDialog({ dialog }) {
+	if (dialog === null) return null;
+	if (dialog.wallet !== null) return /* @__PURE__ */ jsx(StripeWalletDialog, {
+		dialog,
+		wallet: dialog.wallet
+	});
+	return /* @__PURE__ */ jsx(StripeCardDialog, { dialog });
+}
+function StripeCardDialog({ dialog }) {
+	const storefrontTranslate = useStorefrontText();
+	const { locale } = useStorefrontLocale();
+	const container = useRef(null);
+	const stripe = useRef(null);
+	const elements = useRef(null);
+	const latest = useRef(dialog);
+	latest.current = dialog;
+	const mounted = useRef(true);
+	const [ready, setReady] = useState(false);
+	const [busy, setBusy] = useState(false);
+	const [error, setError] = useState(null);
+	const { publishableKey, amount, currency } = dialog;
+	useEffect(() => {
+		mounted.current = true;
+		return () => {
+			mounted.current = false;
+		};
+	}, []);
+	useEffect(() => {
+		let active = true;
+		setReady(false);
+		setError(null);
+		async function mount() {
+			const client = await loadStripeClient(publishableKey, locale);
+			if (!active) return;
+			if (client === null || container.current === null) throw new Error("No pudimos cargar el pago con tarjeta.");
+			stripe.current = client;
+			elements.current = client.elements({
+				mode: "payment",
+				amount: toStripeMinorUnits(amount, currency),
+				currency: currency.toLowerCase(),
+				paymentMethodCreation: "manual",
+				paymentMethodTypes: ["card"]
+			});
+			const element = elements.current.create("payment", { wallets: {
+				applePay: "never",
+				googlePay: "never"
+			} });
+			element.on("ready", () => {
+				if (active) setReady(true);
+			});
+			element.on("loaderror", () => {
+				if (active) setError("No pudimos cargar el formulario. Revisa tu conexión e intenta de nuevo.");
+			});
+			element.mount(container.current);
+		}
+		mount().catch(() => {
+			if (active) setError("No pudimos cargar el pago con tarjeta.");
+		});
+		return () => {
+			active = false;
+			elements.current?.getElement("payment")?.destroy();
+			stripe.current = null;
+			elements.current = null;
+		};
+	}, [
+		publishableKey,
+		amount,
+		currency,
+		locale
+	]);
+	async function pay() {
+		const client = stripe.current;
+		const current = elements.current;
+		if (client === null || current === null || busy) return;
+		setBusy(true);
+		setError(null);
+		try {
+			const submitted = await current.submit();
+			if (submitted.error) {
+				setError(submitted.error.message ?? "Revisa los datos de tu tarjeta.");
+				return;
+			}
+			const created = await client.createPaymentMethod({ elements: current });
+			if (created.error) {
+				setError(created.error.message ?? "No pudimos validar tu tarjeta. Intenta de nuevo.");
+				return;
+			}
+			latest.current.onTokenized(created.paymentMethod.id);
+		} catch {
+			setError("No pudimos validar tu tarjeta. Intenta de nuevo.");
+		} finally {
+			if (mounted.current) setBusy(false);
+		}
+	}
+	let label = storefrontTranslate("Pagar {value0}", { value0: money(amount, currency, locale) });
+	if (busy) label = storefrontTranslate("Procesando…");
+	return /* @__PURE__ */ jsxs(PaymentDialogFrame, {
+		title: storefrontTranslate("Pagar con tarjeta"),
+		onClose: () => latest.current.onClose(),
+		note: storefrontTranslate("Stripe procesa los datos de tu tarjeta de forma segura."),
+		children: [
+			ready ? null : /* @__PURE__ */ jsx("p", {
+				role: "status",
+				className: "py-8 text-center text-sm text-muted-foreground",
+				children: storefrontTranslate("Cargando el pago…")
+			}),
+			/* @__PURE__ */ jsx("div", { ref: container }),
+			error === null ? null : /* @__PURE__ */ jsx("p", {
+				role: "alert",
+				className: "mt-3 text-sm text-destructive",
+				children: storefrontTranslate(error)
+			}),
+			/* @__PURE__ */ jsx("button", {
+				type: "button",
+				onClick: () => {
+					pay();
+				},
+				disabled: !ready || busy,
+				className: "mt-4 w-full rounded-md bg-primary px-4 py-2.5 text-sm font-medium text-primary-foreground disabled:opacity-60",
+				children: label
+			})
+		]
+	});
+}
+function StripeWalletDialog({ dialog, wallet }) {
+	const storefrontTranslate = useStorefrontText();
+	const { locale } = useStorefrontLocale();
+	const container = useRef(null);
+	const latest = useRef(dialog);
+	latest.current = dialog;
+	const [state, setState] = useState("loading");
+	const [error, setError] = useState(null);
+	const { publishableKey, amount, currency } = dialog;
+	useEffect(() => {
+		let active = true;
+		let element;
+		setState("loading");
+		setError(null);
+		async function confirm(client, elements, event) {
+			try {
+				const submitted = await elements.submit();
+				if (submitted.error) {
+					event.paymentFailed({ reason: "fail" });
+					if (active) setError(submitted.error.message ?? "No pudimos completar el pago. Intenta de nuevo.");
+					return;
+				}
+				const created = await client.createPaymentMethod({ elements });
+				if (created.error) {
+					event.paymentFailed({ reason: "fail" });
+					if (active) setError(created.error.message ?? "No pudimos completar el pago. Intenta de nuevo.");
+					return;
+				}
+				latest.current.onTokenized(created.paymentMethod.id);
+			} catch {
+				event.paymentFailed({ reason: "fail" });
+				if (active) setError("No pudimos completar el pago. Intenta de nuevo.");
+			}
+		}
+		async function mount() {
+			const client = await loadStripeClient(publishableKey, locale);
+			if (!active) return;
+			if (client === null || container.current === null) throw new Error("No pudimos cargar el pago.");
+			const elements = client.elements({
+				mode: "payment",
+				amount: toStripeMinorUnits(amount, currency),
+				currency: currency.toLowerCase(),
+				paymentMethodCreation: "manual",
+				paymentMethodTypes: ["card"]
+			});
+			element = elements.create("expressCheckout", {
+				buttonHeight: 48,
+				paymentMethods: expressCheckoutPaymentMethods(wallet)
+			});
+			element.on("ready", (event) => {
+				if (!active) return;
+				if (event.availablePaymentMethods?.[wallet] === true) setState("ready");
+				else setState("unavailable");
+			});
+			element.on("click", (event) => event.resolve());
+			element.on("confirm", (event) => {
+				confirm(client, elements, event);
+			});
+			element.mount(container.current);
+		}
+		mount().catch(() => {
+			if (active) setState("unavailable");
+		});
+		return () => {
+			active = false;
+			element?.destroy();
+		};
+	}, [
+		publishableKey,
+		amount,
+		currency,
+		locale,
+		wallet
+	]);
+	return /* @__PURE__ */ jsxs(PaymentDialogFrame, {
+		title: storefrontTranslate(WALLET_TITLES[wallet]),
+		onClose: () => latest.current.onClose(),
+		note: storefrontTranslate("Stripe procesa tu pago de forma segura."),
+		children: [
+			state === "loading" ? /* @__PURE__ */ jsx("p", {
+				role: "status",
+				className: "py-8 text-center text-sm text-muted-foreground",
+				children: storefrontTranslate("Cargando el pago…")
+			}) : null,
+			state === "unavailable" ? /* @__PURE__ */ jsx("p", {
+				role: "alert",
+				className: "py-4 text-sm text-destructive",
+				children: storefrontTranslate(WALLET_UNAVAILABLE[wallet])
+			}) : null,
+			/* @__PURE__ */ jsx("p", {
+				className: "pb-3 text-center text-sm",
+				children: money(amount, currency, locale)
+			}),
+			/* @__PURE__ */ jsx("div", { ref: container }),
+			error === null ? null : /* @__PURE__ */ jsx("p", {
+				role: "alert",
+				className: "mt-3 text-sm text-destructive",
+				children: storefrontTranslate(error)
+			})
+		]
+	});
+}
+function StripeAuthentication({ payment, orderStatusUrl }) {
+	const storefrontTranslate = useStorefrontText();
+	const { locale } = useStorefrontLocale();
+	const navigate = useNavigate();
+	const clientSecret = payment.clientSecret;
+	const publishableKey = payment.publicConfiguration.publishableKey;
+	useEffect(() => {
+		let active = true;
+		async function finish() {
+			if (clientSecret === null || publishableKey === void 0) return orderStatusUrl;
+			const client = await loadStripeClient(publishableKey, locale);
+			if (client === null) return orderStatusUrl;
+			let status = (await client.retrievePaymentIntent(clientSecret)).paymentIntent?.status;
+			if (status === "requires_action") status = (await client.handleNextAction({ clientSecret })).paymentIntent?.status;
+			if (status !== void 0 && CONFIRMED_INTENT_STATUSES.has(status)) return confirmingPaymentUrl(orderStatusUrl);
+			return orderStatusUrl;
+		}
+		finish().catch(() => orderStatusUrl).then((destination) => {
+			if (active) navigate(destination, { replace: true });
+		});
+		return () => {
+			active = false;
+		};
+	}, [
+		clientSecret,
+		publishableKey,
+		orderStatusUrl,
+		locale,
+		navigate
+	]);
+	return /* @__PURE__ */ jsx("p", {
+		role: "status",
+		className: "py-16 text-center text-sm text-muted-foreground",
+		children: storefrontTranslate("Estamos confirmando tu pago.")
+	});
+}
+export { StripeAuthentication, StripeDialog, findStripeWallet, toStripeMinorUnits, useAvailableStripeWallets };

package/dist/stripe-dialog.d.ts

@@ -0,0 +1,30 @@
+import { OrderPaymentStart } from "@ecomiq/core";
+export type StripeWallet = "applePay" | "googlePay";
+export type StripeDialogState = {
+  publishableKey: string;
+  amount: number;
+  currency: string;
+  wallet: StripeWallet | null;
+  onTokenized: (paymentMethodId: string) => void;
+  onClose: () => void;
+};
+export declare function findStripeWallet(method: {
+  code: string;
+  providerId?: string | null;
+}): StripeWallet | null;
+type StripeWalletMethod = {
+  code: string;
+  providerId?: string | null;
+  publicConfiguration?: {
+    readonly [key: string]: string;
+  } | null;
+};
+export declare function useAvailableStripeWallets(methods: ReadonlyArray<StripeWalletMethod>, amount: number, currency: string): ReadonlySet<StripeWallet>;
+export declare function StripeDialog({ dialog }: {
+  dialog: StripeDialogState | null;
+}): import("react").JSX.Element | null;
+export declare function StripeAuthentication({ payment, orderStatusUrl }: {
+  payment: OrderPaymentStart;
+  orderStatusUrl: string;
+}): import("react").JSX.Element;
+export {};

package/dist/telemetry-HuZXWBPi.js

@@ -0,0 +1,114 @@
+// src/telemetry.ts
+/** Timings for the storefront SDK calls completed before the SSR response headers. */
+var StorefrontSdkTiming = class {
+	count = 0;
+	sumMs = 0;
+	slowestMs = 0;
+	slowestMethod = "";
+	subrequests = 0;
+	recordSubrequest() {
+		this.subrequests += 1;
+	}
+	record(method, durationMs) {
+		this.count += 1;
+		this.sumMs += durationMs;
+		if (durationMs > this.slowestMs) {
+			this.slowestMs = durationMs;
+			this.slowestMethod = method;
+		}
+	}
+};
+const timedClientMethods = /* @__PURE__ */ new Set([
+	"get",
+	"post",
+	"postForm",
+	"request",
+	"graphql",
+	"getSettings",
+	"getLayout",
+	"getStoreId",
+	"getCollections",
+	"getPaymentMethods",
+	"getCollectionBySlug",
+	"getPageBySlug",
+	"getCategoryBySlug",
+	"resolveUrl",
+	"getLinks",
+	"getSitemap",
+	"listArticles",
+	"getArticleBySlug",
+	"getSellers",
+	"getSellerBySlug",
+	"getProducts",
+	"getProductBySlug",
+	"getRelatedProducts",
+	"autocompleteProducts",
+	"listProductReviews",
+	"listStoreReviews",
+	"createProductReview",
+	"createCustomerProductReview",
+	"createCart",
+	"getCart",
+	"addCartItem",
+	"updateCartItemQuantity",
+	"removeCartItem",
+	"getCartCheckout",
+	"getShippingOptions",
+	"patchCartBuyer",
+	"patchCartAddresses",
+	"putCartShippingMethod",
+	"putCartPaymentMethod",
+	"removeCartPromotionCode",
+	"addCartPromotionCode",
+	"checkoutCart",
+	"uploadPaymentReceipt",
+	"getCountries",
+	"getDepartments",
+	"getDistricts",
+	"getProvinces",
+	"getCustomerAddresses",
+	"createCustomerAddress",
+	"updateCustomerAddress",
+	"deleteCustomerAddress",
+	"getCustomerMe",
+	"patchCustomer",
+	"getCustomerOrders",
+	"getCustomerOrder",
+	"requestCustomerOrderReturn",
+	"requestCustomerOrderCancellation",
+	"upsertCustomerAuthConfiguration",
+	"getCustomerSession",
+	"createCustomerSession",
+	"deleteCustomerSession",
+	"getCustomerRegistration",
+	"completeCustomerRegistration",
+	"getOrderStatus",
+	"startOrderPayment",
+	"authenticateOrderPayment",
+	"uploadOrderPaymentReceipt",
+	"getOrderDraft",
+	"checkoutOrderDraft",
+	"getComplaintBook",
+	"createComplaintBookEntry"
+]);
+function observeStorefrontClient(client, timing) {
+	return new Proxy(client, { get(target, property, receiver) {
+		const value = Reflect.get(target, property, receiver);
+		if (typeof property !== "string" || !timedClientMethods.has(property) || typeof value !== "function") return value;
+		return (...args) => {
+			const started = performance.now();
+			try {
+				return Promise.resolve(Reflect.apply(value, target, args)).finally(() => {
+					timing.record(property, performance.now() - started);
+				});
+			} catch (error) {
+				timing.record(property, performance.now() - started);
+				throw error;
+			}
+		};
+	} });
+}
+function durationMetric(name, durationMs) {
+	return `${name};dur=${Math.max(0, durationMs).toFixed(1)}`;
+}
+export { StorefrontSdkTiming, durationMetric, observeStorefrontClient, timedClientMethods };

package/dist/telemetry.d.ts

@@ -0,0 +1,10 @@
+/** Timings for the storefront SDK calls completed before the SSR response headers. */
+export declare class StorefrontSdkTiming {
+  count: number;
+  sumMs: number;
+  slowestMs: number;
+  slowestMethod: string;
+  subrequests: number;
+  recordSubrequest(): void;
+  record(method: string, durationMs: number): void;
+}

package/dist/templates-CAqoNyTW.js

@@ -0,0 +1,40 @@
+import { loadSections, withSections } from "./sections-CNUMWTF_.js";
+import { worker } from "./worker-CNi-gzCu.js";
+// src/templates.ts
+const TEMPLATE = "ecomiqTemplate";
+const NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function templatePath(kind, name) {
+	return `/app/templates/${kind}.${name}.tsx`;
+}
+function field(value, key) {
+	return typeof value === "object" && value !== null ? value[key] : void 0;
+}
+function ownTemplate(kind, page) {
+	if (kind === "product") return field(field(page, "product"), "template");
+	if (kind === "collection") return field(field(page, "collection"), "template");
+	const layout = field(page, "layout");
+	return layout === "default" ? null : layout;
+}
+function templateName(args, modules, kind, page) {
+	let name = ownTemplate(kind, page);
+	const { env } = args.context.get(worker);
+	const forced = env.ECOMIQ_PREVIEW === "1" ? new URL(args.request.url).searchParams.get("template") : null;
+	if (forced !== null) name = forced;
+	if (typeof name !== "string" || !NAME.test(name) || modules[templatePath(kind, name)] === void 0) return null;
+	return name;
+}
+async function templated(args, page, sections, modules, kind) {
+	const name = templateName(args, modules, kind, page);
+	if (name === null) return withSections(page, sections);
+	const own = loadSections(args, modules[templatePath(kind, name)]?.__ecomiqSections ?? []);
+	return withSections(page, {
+		...sections,
+		...own
+	}, { [TEMPLATE]: name });
+}
+function templateComponent(modules, kind, loaderData) {
+	const name = field(loaderData, TEMPLATE);
+	if (typeof name !== "string") return null;
+	return modules[templatePath(kind, name)]?.default ?? null;
+}
+export { templateComponent, templateName, templatePath, templated };

package/dist/templates.d.ts

@@ -0,0 +1,15 @@
+import { SectionData, SectionEntry } from "./sections.js";
+import { LoaderFunctionArgs } from "react-router";
+import { ComponentType } from "react";
+export type TemplateKind = "product" | "collection" | "page";
+export type TemplateModule = {
+  readonly default?: ComponentType<never>;
+  readonly __ecomiqSections?: readonly SectionEntry[];
+};
+export type TemplateModules = {
+  readonly [path: string]: TemplateModule;
+};
+export declare function templatePath(kind: TemplateKind, name: string): string;
+export declare function templateName(args: LoaderFunctionArgs, modules: TemplateModules, kind: TemplateKind, page: unknown): string | null;
+export declare function templated(args: LoaderFunctionArgs, page: unknown, sections: SectionData, modules: TemplateModules, kind: TemplateKind): Promise<unknown>;
+export declare function templateComponent(modules: TemplateModules, kind: TemplateKind, loaderData: unknown): ComponentType<never> | null;

package/dist/urls-CpGQPxvf.js

@@ -0,0 +1,71 @@
+import { readCatalog } from "./catalog-7gJ-l5hW.js";
+import { documentUrl } from "./document-url-CGsAl5Tf.js";
+import { store } from "./store-8Q-_LFrQ.js";
+import { data, redirect } from "react-router";
+import { sanitizeHtml } from "@ecomiq/core";
+// src/urls.ts
+function requestUrl(request) {
+	return documentUrl(new URL(request.url));
+}
+function destination(current, url) {
+	const target = new URL(current);
+	target.pathname = url;
+	return target;
+}
+function moved(target) {
+	return redirect(`/${target.pathname.replace(/^\/+/, "")}${target.search}`, 301);
+}
+function requireCanonical(request, url) {
+	const current = requestUrl(request);
+	const target = destination(current, url);
+	if (target.pathname !== current.pathname) throw moved(target);
+}
+async function resolveUrl(request, context, options = {}) {
+	const current = requestUrl(request);
+	const client = store(context);
+	const resolved = await client.resolveUrl(current.pathname);
+	if (resolved === null) throw data(null, { status: 404 });
+	if (options.redirect === false) {
+		if (resolved.kind !== "redirect") return resolved;
+		const target = await client.resolveUrl(destination(current, resolved.url).pathname);
+		if (target === null || target.kind === "redirect") throw data(null, { status: 404 });
+		return target;
+	}
+	if (resolved.kind === "redirect") throw moved(destination(current, resolved.url));
+	requireCanonical(request, resolved.url);
+	return resolved;
+}
+async function loadProduct(request, context, options = {}) {
+	const resolved = await resolveUrl(request, context, options);
+	if (resolved.kind !== "product") throw data(null, { status: 404 });
+	return resolved.product;
+}
+function canonicalOrigin(request, settings) {
+	if (settings.store.domain) return `https://${settings.store.domain}`;
+	return requestUrl(request).origin;
+}
+function absoluteUrl(origin, url) {
+	return destination(new URL(origin), url).toString();
+}
+async function canonicalUrl(request, context, url) {
+	return absoluteUrl(canonicalOrigin(request, await store(context).getSettings()), url);
+}
+async function loadCategory(request, context, category) {
+	const client = store(context);
+	const query = readCatalog(requestUrl(request), { categoryId: category.id });
+	const result = await client.getProducts(query);
+	let description = null;
+	if (category.description !== null) description = sanitizeHtml(category.description);
+	return {
+		category: {
+			...category,
+			description
+		},
+		page: query.page ?? 1,
+		result: {
+			...result,
+			filters: result.filters.filter((filter) => filter.id !== "category")
+		}
+	};
+}
+export { absoluteUrl, canonicalOrigin, canonicalUrl, loadCategory, loadProduct, requestUrl, requireCanonical, resolveUrl };