@ecomiq/storefront 2.1.4 → 3.0.0

package/dist/analytics/tracker-p4yaoOyk.js

@@ -0,0 +1,51 @@
+import { currentConsent, installConsent, onConsent } from "./consent-B13rBpBs.js";
+// src/analytics/tracker.ts
+const QUEUE_LIMIT = 50;
+let config = null;
+let queue = [];
+let loading = null;
+let destinations = null;
+function granted(consent) {
+	return consent.analytics || consent.marketing;
+}
+function flush(settings, consent, ready) {
+	ready.load(settings, consent);
+	const pending = queue;
+	queue = [];
+	if (granted(consent)) for (const event of pending) ready.send(settings, consent, event);
+}
+function apply(consent) {
+	const settings = config;
+	if (settings === null || consent === null) return;
+	if (destinations !== null) {
+		flush(settings, consent, destinations);
+		return;
+	}
+	if (!granted(consent)) {
+		queue = [];
+		return;
+	}
+	loading ??= import("./destinations-iECrlLIr.js");
+	loading.then((ready) => {
+		destinations = ready;
+		const latest = currentConsent();
+		if (config !== null && latest !== null) flush(config, latest, ready);
+	});
+}
+function configureTracker(settings) {
+	config = settings;
+	installConsent(settings);
+}
+function startTracker() {
+	const stop = onConsent(apply);
+	apply(currentConsent());
+	return stop;
+}
+function track(event) {
+	if (config === null) return;
+	const consent = currentConsent();
+	if (consent !== null && !granted(consent)) return;
+	if (consent !== null && destinations !== null) destinations.send(config, consent, event);
+	else if (queue.length < QUEUE_LIMIT) queue.push(event);
+}
+export { configureTracker, startTracker, track };

package/dist/api-cache-DsuIn5hX.js

@@ -0,0 +1,159 @@
+import { STOREFRONT_SETTINGS_SCHEMA_VERSION } from "@ecomiq/core";
+import { z } from "zod";
+import { STOREFRONT_CACHE_TTL_SECONDS } from "@ecomiq/core/storefront-cache-revision";
+// src/api-cache.ts
+const CACHE_NAME = "ecomiq-api";
+const GEO_CACHE_SECONDS = 43200;
+const STORED_AT = "x-ecomiq-stored-at";
+const PUBLIC_READS = [
+	"settings",
+	"collections",
+	"products",
+	"categories",
+	"urls/resolve",
+	"pages",
+	"payments/methods",
+	"sellers",
+	"articles",
+	"geo",
+	"sitemap"
+];
+const PRIVATE_HEADERS = [
+	"authorization",
+	"cookie",
+	"x-customer-session"
+];
+const NO_SHARED_CACHE = /(?:^|,)\s*(?:private|no-store|no-cache|max-age\s*=\s*0|s-maxage\s*=\s*0)\b/i;
+const GraphQLErrorsSchema = z.object({ errors: z.array(z.object({ extensions: z.object({ code: z.string().optional() }).optional() })) });
+const REVOKED_GRAPHQL_CODES = /* @__PURE__ */ new Set([
+	"NOT_FOUND",
+	"FORBIDDEN",
+	"UNAUTHENTICATED",
+	"AUTH_NOT_AUTHENTICATED",
+	"AUTH_NOT_AUTHORIZED",
+	"STORE_CONTEXT_REQUIRED"
+]);
+function graphQLRead(request) {
+	return request.method === "POST" && new URL(request.url).pathname.endsWith("/graphql");
+}
+function catalogLinksRead(request) {
+	return request.method === "POST" && new URL(request.url).pathname.endsWith("/v1/urls/links");
+}
+function publicRead(request) {
+	if (PRIVATE_HEADERS.some((header) => request.headers.has(header))) return false;
+	if (NO_SHARED_CACHE.test(request.headers.get("cache-control") ?? "") || request.cache === "no-store" || request.cache === "no-cache") return false;
+	if (graphQLRead(request) || catalogLinksRead(request)) return true;
+	if (request.method !== "GET") return false;
+	const path = new URL(request.url).pathname.split("/v1/")[1] ?? "";
+	if (path === "reviews") return true;
+	if (path.endsWith("/reviews")) return false;
+	return PUBLIC_READS.some((read) => path === read || path.startsWith(`${read}/`));
+}
+function geoRead(request) {
+	const path = new URL(request.url).pathname.split("/v1/")[1] ?? "";
+	return path === "geo" || path.startsWith("geo/");
+}
+async function cacheKey(request, store, cacheRevision) {
+	const url = new URL(request.url);
+	url.searchParams.set("__ecomiq_store", store);
+	if (!geoRead(request)) url.searchParams.set("__ecomiq_revision", cacheRevision);
+	const storeId = request.headers.get("x-store-id");
+	if (storeId !== null) url.searchParams.set("__ecomiq_store_id", storeId);
+	if (url.pathname.endsWith("/v1/settings")) url.searchParams.set("__ecomiq_settings_schema", String(STOREFRONT_SETTINGS_SCHEMA_VERSION));
+	if (request.method === "POST") {
+		const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(await request.clone().text()));
+		url.searchParams.set("__ecomiq_query", [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join(""));
+	}
+	return new Request(`https://ecomiq-api.cache/${url.host}${url.pathname}${url.search}`);
+}
+function countedFetch(count) {
+	return (input, init) => {
+		count();
+		return fetch(input, init);
+	};
+}
+function uncachedFetch(count) {
+	return (input, init) => {
+		const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+		headers.set("cache-control", "no-store");
+		count();
+		return fetch(input, {
+			...init,
+			headers,
+			cache: "no-store"
+		});
+	};
+}
+async function load(cache, key, request, maxAge, count, ctx, hasCachedResponse = false) {
+	count();
+	const response = await fetch(request);
+	const shareable = response.status === 200 && !response.headers.has("set-cookie") && !NO_SHARED_CACHE.test(response.headers.get("cache-control") ?? "") && (response.headers.get("vary") ?? "").split(",").every((header) => ["", "accept-encoding"].includes(header.trim().toLowerCase()));
+	if ([
+		401,
+		403,
+		404,
+		410
+	].includes(response.status) || response.status === 200 && !shareable) {
+		if (hasCachedResponse) {
+			count();
+			await cache.delete(key).catch(() => void 0);
+		}
+		return response;
+	}
+	if (!shareable) return response;
+	const headers = new Headers(response.headers);
+	headers.set("cache-control", `public, max-age=${maxAge}`);
+	headers.set(STORED_AT, String(Date.now()));
+	const copy = response.clone();
+	const write = (async () => {
+		if (graphQLRead(request)) {
+			const body = await copy.arrayBuffer();
+			const result = JSON.parse(new TextDecoder().decode(body));
+			if (result === null || typeof result !== "object") return;
+			if ("errors" in result) {
+				const parsed = GraphQLErrorsSchema.safeParse(result);
+				if (hasCachedResponse && parsed.success && parsed.data.errors.some((error) => error.extensions?.code !== void 0 && REVOKED_GRAPHQL_CODES.has(error.extensions.code))) {
+					count();
+					await cache.delete(key).catch(() => void 0);
+				}
+				return;
+			}
+			count();
+			await cache.put(key, new Response(body, {
+				status: 200,
+				headers
+			}));
+		} else {
+			count();
+			await cache.put(key, new Response(copy.body, {
+				status: 200,
+				headers
+			}));
+		}
+	})().catch(() => void 0);
+	if (ctx) ctx.waitUntil(write);
+	else await write;
+	return response;
+}
+function apiCacheFetch(ctx, store, count, cacheRevision) {
+	if (typeof caches === "undefined") return void 0;
+	return async (input, init) => {
+		const request = new Request(input, init);
+		if (!publicRead(request)) return countedFetch(count)(request);
+		const maxAge = geoRead(request) ? GEO_CACHE_SECONDS : STOREFRONT_CACHE_TTL_SECONDS;
+		let cache;
+		try {
+			cache = await caches.open(CACHE_NAME);
+		} catch {
+			return uncachedFetch(count)(request);
+		}
+		const key = await cacheKey(request, store, cacheRevision);
+		count();
+		const cached = await cache.match(key).catch(() => void 0);
+		if (!cached) return load(cache, key, request, maxAge, count, ctx);
+		const age = (Date.now() - Number(cached.headers.get(STORED_AT) ?? 0)) / 1e3;
+		if (!(age >= 0 && age < maxAge)) return load(cache, key, request, maxAge, count, ctx, true);
+		return cached;
+	};
+}
+export { apiCacheFetch, countedFetch, uncachedFetch };

package/dist/bank-accounts-DlEczQQ5.js

@@ -0,0 +1,81 @@
+import { useStorefrontText } from "./storefront-language-DrMjVbmk.js";
+import { useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+// src/bank-accounts.tsx
+const ACCOUNT_TYPES = {
+	savings: "Ahorros",
+	checking: "Corriente"
+};
+const CURRENCIES = {
+	PEN: "soles",
+	USD: "dólares"
+};
+function CopyValue({ label, value }) {
+	const storefrontTranslate = useStorefrontText();
+	const [copied, setCopied] = useState(false);
+	return /* @__PURE__ */ jsxs("span", {
+		className: "flex items-center justify-between gap-3",
+		children: [/* @__PURE__ */ jsxs("span", {
+			className: "min-w-0 break-all",
+			children: [
+				label,
+				" ",
+				/* @__PURE__ */ jsx("span", {
+					className: "font-medium tabular-nums",
+					children: value
+				})
+			]
+		}), /* @__PURE__ */ jsx("button", {
+			type: "button",
+			className: "shrink-0 text-xs font-medium underline underline-offset-2",
+			onClick: () => {
+				navigator.clipboard?.writeText(value).then(() => setCopied(true));
+			},
+			children: copied ? storefrontTranslate("Copiado") : storefrontTranslate("Copiar")
+		})]
+	});
+}
+function BankAccountList({ accounts }) {
+	const storefrontTranslate = useStorefrontText();
+	if (accounts.length === 0) return null;
+	return /* @__PURE__ */ jsx("ul", {
+		className: "grid gap-2",
+		children: accounts.map((account) => {
+			const type = storefrontTranslate(ACCOUNT_TYPES[account.accountType] ?? account.accountType);
+			const currency = storefrontTranslate(CURRENCIES[account.currencyCode] ?? account.currencyCode);
+			return /* @__PURE__ */ jsxs("li", {
+				className: "grid gap-1 rounded-md border border-input bg-background px-3 py-2",
+				children: [
+					/* @__PURE__ */ jsxs("span", {
+						className: "font-medium",
+						children: [
+							account.bankName,
+							" · ",
+							storefrontTranslate("{value0} en {value1}", {
+								value0: type,
+								value1: currency
+							})
+						]
+					}),
+					/* @__PURE__ */ jsx(CopyValue, {
+						label: storefrontTranslate("Cuenta"),
+						value: account.accountNumber
+					}),
+					account.interbankAccountNumber ? /* @__PURE__ */ jsx(CopyValue, {
+						label: "CCI",
+						value: account.interbankAccountNumber
+					}) : null,
+					/* @__PURE__ */ jsxs("span", {
+						className: "text-muted-foreground",
+						children: [
+							storefrontTranslate("Titular:"),
+							" ",
+							account.accountHolder
+						]
+					})
+				]
+			}, `${account.bankName}-${account.accountNumber}`);
+		})
+	});
+}
+export { BankAccountList };

package/dist/bank-accounts.d.ts

@@ -0,0 +1,4 @@
+import { PaymentBankAccount } from "@ecomiq/core";
+export declare function BankAccountList({ accounts }: {
+  accounts: readonly PaymentBankAccount[];
+}): import("react").JSX.Element | null;

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;