@ecomiq/storefront 2.1.4 → 3.0.1

package/dist/captcha-DAqaIx8m.js

@@ -0,0 +1,117 @@
+import { useStorefrontText } from "./storefront-language-DrMjVbmk.js";
+import { text } from "./form-BtQcbXlJ.js";
+import { useEffect, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+// src/captcha.tsx
+const CAPTCHA_FIELDS = {
+	turnstile: "cf-turnstile-response",
+	recaptcha: "g-recaptcha-response"
+};
+const captchaScripts = /* @__PURE__ */ new Map();
+function captchaResponse(form, provider) {
+	if (provider === "off") return "";
+	return text(form, CAPTCHA_FIELDS[provider]);
+}
+function loadCaptcha(provider) {
+	const saved = captchaScripts.get(provider);
+	if (saved) return saved;
+	const loading = new Promise((resolve, reject) => {
+		const script = document.createElement("script");
+		script.src = provider === "turnstile" ? "https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit" : "https://www.google.com/recaptcha/api.js?render=explicit";
+		script.async = true;
+		script.defer = true;
+		script.onload = () => resolve();
+		script.onerror = () => {
+			captchaScripts.delete(provider);
+			script.remove();
+			reject(/* @__PURE__ */ new Error("Captcha unavailable"));
+		};
+		document.head.appendChild(script);
+	});
+	captchaScripts.set(provider, loading);
+	return loading;
+}
+function Captcha({ captcha, action, errorClass, busy }) {
+	const storefrontTranslate = useStorefrontText();
+	const element = useRef(null);
+	const widget = useRef(null);
+	const submitted = useRef(false);
+	const [token, setToken] = useState("");
+	const [failed, setFailed] = useState(false);
+	useEffect(() => {
+		if (captcha.provider === "off" || !captcha.siteKey || !captcha.isConfigured) return;
+		const provider = captcha.provider;
+		const siteKey = captcha.siteKey;
+		let active = true;
+		loadCaptcha(provider).then(async () => {
+			if (!active || !element.current) return;
+			const api = provider === "turnstile" ? window.turnstile : window.grecaptcha;
+			if (!api) throw new Error("Captcha unavailable");
+			if (api.ready) await new Promise((resolve) => api.ready(resolve));
+			if (!active || !element.current) return;
+			const id = api.render(element.current, {
+				sitekey: siteKey,
+				action: provider === "turnstile" ? action : void 0,
+				size: element.current.clientWidth < 304 ? "compact" : "normal",
+				callback: (value) => {
+					setToken(value);
+					setFailed(false);
+				},
+				"expired-callback": () => setToken(""),
+				"error-callback": () => {
+					setToken("");
+					setFailed(true);
+				}
+			});
+			widget.current = {
+				api,
+				id
+			};
+		}).catch(() => {
+			if (active) setFailed(true);
+		});
+		return () => {
+			active = false;
+			const rendered = widget.current;
+			if (rendered?.api.remove) rendered.api.remove(rendered.id);
+			else if (rendered) rendered.api.reset(rendered.id);
+			widget.current = null;
+		};
+	}, [
+		captcha.provider,
+		captcha.siteKey,
+		captcha.isConfigured,
+		action
+	]);
+	useEffect(() => {
+		if (busy) {
+			submitted.current = true;
+			return;
+		}
+		if (!submitted.current) return;
+		submitted.current = false;
+		setToken("");
+		const rendered = widget.current;
+		if (rendered) rendered.api.reset(rendered.id);
+	}, [busy]);
+	if (captcha.provider === "off") return null;
+	if (!captcha.isConfigured) return /* @__PURE__ */ jsx("p", {
+		className: errorClass,
+		role: "alert",
+		children: storefrontTranslate("La tienda debe completar la configuración de verificación. Intenta más tarde.")
+	});
+	return /* @__PURE__ */ jsxs("div", { children: [
+		/* @__PURE__ */ jsx("div", { ref: element }),
+		/* @__PURE__ */ jsx("input", {
+			type: "hidden",
+			name: CAPTCHA_FIELDS[captcha.provider],
+			value: token
+		}),
+		failed ? /* @__PURE__ */ jsx("p", {
+			className: errorClass,
+			role: "alert",
+			children: storefrontTranslate("No se pudo cargar la verificación. Recarga la página e intenta de nuevo.")
+		}) : null
+	] });
+}
+export { Captcha, captchaResponse };

package/dist/captcha.d.ts

@@ -0,0 +1,34 @@
+export type CaptchaProvider = "off" | "turnstile" | "recaptcha";
+export type CaptchaConfiguration = {
+  provider: CaptchaProvider;
+  siteKey: string | null;
+  isConfigured: boolean;
+};
+export type CaptchaProps = {
+  captcha: CaptchaConfiguration;
+  action: string;
+  errorClass: string;
+  busy: boolean;
+};
+type CaptchaOptions = {
+  sitekey: string;
+  action?: string;
+  size: "normal" | "compact";
+  callback: (token: string) => void;
+  "expired-callback": () => void;
+  "error-callback": () => void;
+};
+type CaptchaApi = {
+  ready?: (callback: () => void) => void;
+  render: (container: HTMLElement, options: CaptchaOptions) => string | number;
+  remove?: (id: string | number) => void;
+  reset: (id: string | number) => void;
+};
+declare global {
+  interface Window {
+    turnstile?: CaptchaApi;
+    grecaptcha?: CaptchaApi;
+  }
+}
+export declare function Captcha({ captcha, action, errorClass, busy }: CaptchaProps): import("react").JSX.Element | null;
+export {};

package/dist/cart-D7DxZ2lD.js

@@ -0,0 +1,30 @@
+import { createCookie } from "react-router";
+// src/cart.ts
+const cartCookie = createCookie("__Host-ecomiq-cart", {
+	httpOnly: true,
+	sameSite: "lax",
+	secure: true,
+	path: "/",
+	maxAge: 2592e3
+});
+async function cartToken(request) {
+	const value = await cartCookie.parse(request.headers.get("Cookie"));
+	return typeof value === "string" && value !== "" ? value : null;
+}
+const CLOSED = /* @__PURE__ */ new Set([
+	"completed",
+	"cancelled",
+	"expired",
+	"failed"
+]);
+async function readCart(request, client) {
+	const token = await cartToken(request);
+	if (token === null) return null;
+	try {
+		const cart = await client.getCart({ cartToken: token });
+		return CLOSED.has(cart.status) ? null : cart;
+	} catch {
+		return null;
+	}
+}
+export { cartCookie, cartToken, readCart };

package/dist/cart-actions-Bsub_FFG.js

@@ -0,0 +1,116 @@
+import { cartCookie, cartToken, readCart } from "./cart-D7DxZ2lD.js";
+import { text } from "./form-BtQcbXlJ.js";
+import { CART_INTENTS, isIntent } from "./form-contracts-BNpHaTGJ.js";
+import { store } from "./store-8Q-_LFrQ.js";
+import { data, redirect } from "react-router";
+import { ApiError } from "@ecomiq/core";
+// src/cart-actions.ts
+const MAX_CART_QUANTITY = 999;
+const MAX_REORDER_LINES = 20;
+const ERRORS = {
+	"Catalog.InsufficientStock": "No hay stock suficiente para esa cantidad.",
+	"Inventory.InsufficientStock": "No hay stock suficiente para esa cantidad.",
+	"Catalog.VariantNotFound": "Este producto ya no está disponible.",
+	"Carts.QuantityOutOfRange": "Esa cantidad supera el máximo por pedido.",
+	"Carts.ItemNotFound": "Ese producto ya no está en tu carrito.",
+	"Checkout.InProgress": "Tu compra se está pagando. Termina el pago antes de cambiar el carrito."
+};
+const CLOSED = /* @__PURE__ */ new Set(["Carts.NotActive", "Carts.NotFound"]);
+function failure(message, headers) {
+	return data({
+		ok: false,
+		message
+	}, {
+		status: 400,
+		headers
+	});
+}
+async function apiFailure(error) {
+	if (error.code !== void 0 && CLOSED.has(error.code)) return failure("Tu carrito anterior ya se cerró. Vuelve a agregar el producto.", { "Set-Cookie": await cartCookie.serialize("", { maxAge: 0 }) });
+	if (error.code?.startsWith("Modifiers.")) return failure("Revisa las opciones elegidas.");
+	return failure((error.code === void 0 ? void 0 : ERRORS[error.code]) ?? "No pudimos actualizar el carrito. Intenta de nuevo.");
+}
+function quantity(form, minimum) {
+	const value = Math.floor(Number(text(form, "quantity")));
+	if (!Number.isFinite(value) || value < minimum) return minimum;
+	return Math.min(999, value);
+}
+function reorderLines(form) {
+	const quantities = form.getAll("quantity");
+	return form.getAll("variantId").map((value, index) => {
+		const amount = Math.floor(Number(quantities[index]));
+		return {
+			variantId: typeof value === "string" ? value.trim() : "",
+			quantity: Number.isFinite(amount) && amount > 0 ? Math.min(999, amount) : 1
+		};
+	}).filter((line) => line.variantId !== "").slice(0, MAX_REORDER_LINES);
+}
+async function availableVariant(client, slug) {
+	if (!slug) return null;
+	return (await client.getProductBySlug(slug)).variants.find((candidate) => candidate.id !== null && candidate.isAvailable !== false)?.id ?? null;
+}
+function goesToCheckout(intent, form) {
+	if (intent === "buy") return true;
+	if (intent !== "add" && intent !== "quick") return false;
+	const next = text(form, "next");
+	return next === "/checkout" || next === "checkout";
+}
+async function loadCart(request, context) {
+	return { cart: await readCart(request, store(context)) };
+}
+async function cartAction(request, context) {
+	const client = store(context);
+	const form = await request.formData();
+	const intent = text(form, "intent");
+	if (!isIntent(CART_INTENTS, intent)) return failure("Acción no válida.");
+	try {
+		let cart = await readCart(request, client);
+		if (cart === null) {
+			const settings = await client.getSettings();
+			cart = await client.createCart({ currencyCode: settings.store.currency });
+		}
+		if (intent === "add" || intent === "buy" || intent === "quick") {
+			const variantId = text(form, "variantId") || await availableVariant(client, text(form, "product"));
+			if (!variantId) return failure("Este producto no está disponible.");
+			const added = intent === "quick" ? 1 : quantity(form, 1);
+			cart = await client.addCartItem({
+				cartToken: cart.token,
+				variantId,
+				quantity: added
+			});
+		} else if (intent === "reorder") {
+			let added = 0;
+			for (const line of reorderLines(form)) try {
+				cart = await client.addCartItem({
+					cartToken: cart.token,
+					variantId: line.variantId,
+					quantity: line.quantity
+				});
+				added += 1;
+			} catch (error) {
+				if (!(error instanceof ApiError) || error.status < 400 || error.status >= 500 || error.code !== void 0 && CLOSED.has(error.code)) throw error;
+			}
+			if (added === 0) return failure("Estos productos ya no están disponibles.");
+		} else if (intent === "update") cart = await client.updateCartItemQuantity({
+			cartToken: cart.token,
+			cartItemId: text(form, "itemId"),
+			quantity: quantity(form, 0)
+		});
+		else cart = await client.removeCartItem({
+			cartToken: cart.token,
+			cartItemId: text(form, "itemId")
+		});
+		let headers;
+		if (await cartToken(request) !== cart.token) headers = { "Set-Cookie": await cartCookie.serialize(cart.token) };
+		if (goesToCheckout(intent, form)) return redirect("/checkout", { headers });
+		if (intent === "reorder") return redirect("/cart", { headers });
+		return data({
+			ok: true,
+			message: ""
+		}, { headers });
+	} catch (error) {
+		if (error instanceof ApiError && error.status >= 400 && error.status < 500) return apiFailure(error);
+		return failure("No pudimos actualizar el carrito. Intenta de nuevo.");
+	}
+}
+export { MAX_CART_QUANTITY, cartAction, loadCart };

package/dist/cart-actions.d.ts

@@ -0,0 +1,15 @@
+import { RouterContextProvider } from "react-router";
+import { StorefrontCart } from "@ecomiq/core";
+export declare const MAX_CART_QUANTITY = 999;
+export type CartData = {
+  cart: StorefrontCart | null;
+};
+export type CartActionData = {
+  ok: true;
+  message: "";
+} | {
+  ok: false;
+  message: string;
+};
+export declare function loadCart(request: Request, context: Readonly<RouterContextProvider>): Promise<CartData>;
+export declare function cartAction(request: Request, context: Readonly<RouterContextProvider>): Promise<import("react-router").UNSAFE_DataWithResponseInit<CartActionData> | Response>;

package/dist/cart-drawer-B7PPsR69.js

@@ -0,0 +1,22 @@
+import { createContext, useContext, useMemo, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+// src/cart-drawer.tsx
+const CartDrawerContext = createContext({
+	open: false,
+	setOpen: () => void 0
+});
+function CartDrawerProvider({ children }) {
+	const [open, setOpen] = useState(false);
+	const drawer = useMemo(() => ({
+		open,
+		setOpen
+	}), [open]);
+	return /* @__PURE__ */ jsx(CartDrawerContext.Provider, {
+		value: drawer,
+		children
+	});
+}
+function useCartDrawer() {
+	return useContext(CartDrawerContext);
+}
+export { CartDrawerProvider, useCartDrawer };

package/dist/cart-drawer.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from "react";
+export type CartDrawer = {
+  open: boolean;
+  setOpen: (open: boolean) => void;
+};
+export declare function CartDrawerProvider({ children }: {
+  children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useCartDrawer(): CartDrawer;

package/dist/cart-form-y9P1r_EX.js

@@ -0,0 +1,81 @@
+import { CustomerCsrfField, useCustomerCsrfToken } from "./customer-csrf-C1oDX-Py.js";
+import { CUSTOMER_CSRF_FIELD } from "./form-contracts-BNpHaTGJ.js";
+import { Form, useFetcher } from "react-router";
+import { jsx, jsxs } from "react/jsx-runtime";
+// src/cart-form.tsx
+const CART_ACTION = "/cart";
+function Hidden({ name, value }) {
+	if (value === void 0) return null;
+	return /* @__PURE__ */ jsx("input", {
+		type: "hidden",
+		name,
+		value
+	});
+}
+function CartForm({ intent, itemId, variantId, product, quantity, next, fetcher, children, ...props }) {
+	const Component = fetcher ? fetcher.Form : Form;
+	return /* @__PURE__ */ jsxs(Component, {
+		method: "post",
+		action: CART_ACTION,
+		...props,
+		children: [
+			/* @__PURE__ */ jsx(CustomerCsrfField, {}),
+			/* @__PURE__ */ jsx(Hidden, {
+				name: "intent",
+				value: intent
+			}),
+			/* @__PURE__ */ jsx(Hidden, {
+				name: "itemId",
+				value: itemId
+			}),
+			/* @__PURE__ */ jsx(Hidden, {
+				name: "variantId",
+				value: variantId
+			}),
+			/* @__PURE__ */ jsx(Hidden, {
+				name: "product",
+				value: product
+			}),
+			/* @__PURE__ */ jsx(Hidden, {
+				name: "quantity",
+				value: quantity
+			}),
+			/* @__PURE__ */ jsx(Hidden, {
+				name: "next",
+				value: next
+			}),
+			children
+		]
+	});
+}
+function useCart() {
+	const fetcher = useFetcher();
+	const csrf = useCustomerCsrfToken();
+	function submit(intent, fields) {
+		const form = new FormData();
+		form.set("intent", intent);
+		for (const [name, value] of Object.entries(fields)) form.set(name, value);
+		if (csrf) form.set(CUSTOMER_CSRF_FIELD, csrf);
+		fetcher.submit(form, {
+			method: "post",
+			action: CART_ACTION
+		});
+	}
+	let error = null;
+	if (fetcher.state === "idle" && fetcher.data?.ok === false) error = fetcher.data.message;
+	return {
+		fetcher,
+		busy: fetcher.state !== "idle",
+		error,
+		add: (variantId, quantity = 1) => submit("add", {
+			variantId,
+			quantity: String(Math.max(1, quantity))
+		}),
+		update: (itemId, quantity) => submit("update", {
+			itemId,
+			quantity: String(Math.max(0, quantity))
+		}),
+		remove: (itemId) => submit("remove", { itemId })
+	};
+}
+export { CART_ACTION, CartForm, useCart };

package/dist/cart-form.d.ts

@@ -0,0 +1,24 @@
+import { CartActionData } from "./cart-actions.js";
+import { CartIntent } from "./form-contracts.js";
+import { FetcherFormProps, FetcherWithComponents } from "react-router";
+import { Ref } from "react";
+export type CartFormProps = Omit<FetcherFormProps, "action" | "method" | "encType"> & {
+  ref?: Ref<HTMLFormElement>;
+  intent?: CartIntent;
+  itemId?: string;
+  variantId?: string;
+  product?: string;
+  quantity?: number;
+  next?: string;
+  fetcher?: FetcherWithComponents<CartActionData>;
+};
+export type CartControls = {
+  fetcher: FetcherWithComponents<CartActionData>;
+  busy: boolean;
+  error: string | null;
+  add: (variantId: string, quantity?: number) => void;
+  update: (itemId: string, quantity: number) => void;
+  remove: (itemId: string) => void;
+};
+export declare function CartForm({ intent, itemId, variantId, product, quantity, next, fetcher, children, ...props }: CartFormProps): import("react").JSX.Element;
+export declare function useCart(): CartControls;

package/dist/cart-summary-ur2VWKr-.js

@@ -0,0 +1,89 @@
+// src/cart-summary.ts
+const LABELS = {
+	subtotal: "Subtotal",
+	discount: "Descuentos",
+	shipping: "Envío",
+	tax: "Impuestos",
+	total: "Total",
+	free: "Gratis",
+	pending: "Por calcular"
+};
+function lineSubtotal(items) {
+	return items.reduce((sum, item) => sum + item.unitPrice * item.quantity, 0);
+}
+function groupBySeller(items, marketplace) {
+	if (!marketplace) return [{
+		seller: null,
+		items: [...items],
+		subtotal: lineSubtotal(items)
+	}];
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) groups.set(item.sellerName, [...groups.get(item.sellerName) ?? [], item]);
+	return [...groups.entries()].map(([seller, list]) => ({
+		seller,
+		items: list,
+		subtotal: lineSubtotal(list)
+	}));
+}
+function amountLine(key, label, amount) {
+	return {
+		key,
+		label,
+		amount,
+		text: null,
+		pending: false
+	};
+}
+function lines(totals, shipping, labels) {
+	const result = [amountLine("subtotal", labels.subtotal, totals.subtotal)];
+	if (totals.discount > 0) result.push(amountLine("discount", labels.discount, -totals.discount));
+	if (shipping) result.push(shipping);
+	if (totals.tax > 0) result.push(amountLine("tax", labels.tax, totals.tax));
+	result.push(amountLine("total", labels.total, totals.total));
+	return result;
+}
+function shippingLine(amount, labels) {
+	if (amount === null) return {
+		key: "shipping",
+		label: labels.shipping,
+		amount: null,
+		text: labels.pending,
+		pending: true
+	};
+	if (amount === 0) return {
+		key: "shipping",
+		label: labels.shipping,
+		amount: null,
+		text: labels.free,
+		pending: false
+	};
+	return amountLine("shipping", labels.shipping, amount);
+}
+function summaryLines(cart, labels = {}) {
+	const text = {
+		...LABELS,
+		...labels
+	};
+	let shipping = null;
+	if (cart.items.some((item) => item.requiresShipping)) shipping = shippingLine(cart.shippingMethods.length > 0 ? cart.totals.shippingTotal : null, text);
+	const { subtotal, discountTotal, taxTotal, total } = cart.totals;
+	return lines({
+		subtotal,
+		discount: discountTotal,
+		tax: taxTotal,
+		total
+	}, shipping, text);
+}
+function orderSummaryLines(order, labels = {}) {
+	const text = {
+		...LABELS,
+		...labels
+	};
+	return lines({
+		subtotal: order.subTotal,
+		discount: order.discount,
+		tax: order.tax,
+		total: order.total
+	}, shippingLine(order.shipping, text), text);
+}
+export { groupBySeller, orderSummaryLines, summaryLines };

package/dist/cart-summary.d.ts

@@ -0,0 +1,31 @@
+import { StorefrontCart } from "@ecomiq/core";
+export type SellerLine = {
+  sellerName: string | null;
+  unitPrice: number;
+  quantity: number;
+};
+export type SellerGroup<T extends SellerLine> = {
+  seller: string | null;
+  items: T[];
+  subtotal: number;
+};
+export type SummaryLineKey = "subtotal" | "discount" | "shipping" | "tax" | "total";
+export type SummaryLine = {
+  key: SummaryLineKey;
+  label: string;
+  amount: number | null;
+  text: string | null;
+  pending: boolean;
+};
+export type SummaryLabels = Partial<Record<SummaryLineKey | "free" | "pending", string>>;
+export type SummaryCart = Pick<StorefrontCart, "items" | "totals" | "shippingMethods">;
+export type SummaryOrder = {
+  subTotal: number;
+  discount: number;
+  shipping: number;
+  tax: number;
+  total: number;
+};
+export declare function groupBySeller<T extends SellerLine>(items: readonly T[], marketplace: boolean): SellerGroup<T>[];
+export declare function summaryLines(cart: SummaryCart, labels?: SummaryLabels): SummaryLine[];
+export declare function orderSummaryLines(order: SummaryOrder, labels?: SummaryLabels): SummaryLine[];

package/dist/cart.d.ts

@@ -0,0 +1,4 @@
+import { StorefrontCart, StorefrontClient } from "@ecomiq/core";
+export declare const cartCookie: import("react-router").Cookie;
+export declare function cartToken(request: Request): Promise<string | null>;
+export declare function readCart(request: Request, client: StorefrontClient): Promise<StorefrontCart | null>;

package/dist/catalog-7gJ-l5hW.js

@@ -0,0 +1,67 @@
+// src/catalog.ts
+const LISTS = {
+	category: "categories",
+	brand: "brands",
+	collection: "collections",
+	productType: "productTypes",
+	tag: "tags",
+	seller: "sellers"
+};
+const SORTS = [
+	"newest",
+	"price_asc",
+	"price_desc",
+	"name_asc",
+	"name_desc"
+];
+const CATALOG_PARAMETERS = /* @__PURE__ */ new Set([
+	"q",
+	"sort",
+	"page",
+	"availability",
+	"minPrice",
+	"maxPrice",
+	...Object.keys(LISTS)
+]);
+/** Menus, customer and cart data do not depend on filters in the current catalog. */
+function shouldRevalidateCatalogRoot(args) {
+	const { currentUrl, nextUrl, defaultShouldRevalidate, formMethod, actionResult, actionStatus } = args;
+	if (!defaultShouldRevalidate || formMethod !== void 0 && formMethod.toUpperCase() !== "GET" || actionResult !== void 0 || actionStatus !== void 0 || currentUrl.origin !== nextUrl.origin || currentUrl.pathname !== nextUrl.pathname || currentUrl.search === nextUrl.search) return defaultShouldRevalidate;
+	for (const params of [currentUrl.searchParams, nextUrl.searchParams]) for (const name of params.keys()) if (!CATALOG_PARAMETERS.has(name) && !/^(?:option|attribute):.+$/.test(name)) return defaultShouldRevalidate;
+	return false;
+}
+function isSort(value) {
+	return SORTS.some((sort) => sort === value);
+}
+function price(value) {
+	if (value === null || value.trim() === "") return void 0;
+	const number = Number(value);
+	return Number.isFinite(number) && number >= 0 ? number : void 0;
+}
+function readCatalog(url, base = {}) {
+	const params = url.searchParams;
+	const query = {
+		...base,
+		pageSize: 24,
+		page: Math.max(1, Number(params.get("page") ?? "1") || 1)
+	};
+	const q = params.get("q")?.trim();
+	if (q) query.search = q;
+	const sort = params.get("sort");
+	if (isSort(sort)) query.sort = sort;
+	for (const [id, key] of Object.entries(LISTS)) {
+		const values = params.getAll(id).filter((value) => value !== "");
+		if (values.length > 0) query[key] = values;
+	}
+	const filters = [...params.entries()].filter(([key]) => key.startsWith("option:") || key.startsWith("attribute:")).map(([key, value]) => `${key}:${value}`);
+	if (filters.length > 0) query.filters = filters;
+	const availability = params.get("availability");
+	if (availability === "in_stock") query.inStock = true;
+	if (availability === "out_of_stock") query.inStock = false;
+	const minPrice = price(params.get("minPrice"));
+	const maxPrice = price(params.get("maxPrice"));
+	if (minPrice !== void 0) query.minPrice = minPrice;
+	if (maxPrice !== void 0) query.maxPrice = maxPrice;
+	return query;
+}
+export { readCatalog, shouldRevalidateCatalogRoot };