@ecomiq/storefront 2.1.4 → 3.0.1

package/dist/analytics/destinations-iECrlLIr.js

@@ -0,0 +1,144 @@
+// src/analytics/destinations.ts
+const TOOLS = [
+	"googleAnalytics",
+	"googleTagManager",
+	"metaPixel",
+	"scripts"
+];
+const DENIED = {
+	ad_storage: "denied",
+	ad_user_data: "denied",
+	ad_personalization: "denied",
+	analytics_storage: "denied"
+};
+const META_EVENTS = {
+	page_view: "PageView",
+	search: "Search",
+	view_item: "ViewContent",
+	add_to_cart: "AddToCart",
+	begin_checkout: "InitiateCheckout",
+	purchase: "Purchase"
+};
+const loaded = /* @__PURE__ */ new Set();
+function grant(value) {
+	return value ? "granted" : "denied";
+}
+function googleConsent(consent) {
+	return {
+		ad_storage: grant(consent.marketing),
+		ad_user_data: grant(consent.marketing),
+		ad_personalization: grant(consent.marketing),
+		analytics_storage: grant(consent.analytics)
+	};
+}
+function script(parent, source) {
+	const element = document.createElement("script");
+	if ("src" in source) {
+		element.async = true;
+		element.src = source.src;
+	} else element.text = source.text;
+	parent.appendChild(element);
+}
+function gtag() {
+	if (window.gtag) return window.gtag;
+	const layer = window.dataLayer ??= [];
+	window.gtag = function() {
+		layer.push(arguments);
+	};
+	window.gtag("consent", "default", DENIED);
+	return window.gtag;
+}
+function metaPixel() {
+	if (window.fbq) return window.fbq;
+	const pixel = function(...args) {
+		if (pixel.callMethod) pixel.callMethod.apply(pixel, args);
+		else pixel.queue.push(args);
+	};
+	pixel.push = pixel;
+	pixel.loaded = true;
+	pixel.version = "2.0";
+	pixel.queue = [];
+	window.fbq = pixel;
+	window._fbq = pixel;
+	script(document.head, { src: "https://connect.facebook.net/en_US/fbevents.js" });
+	return pixel;
+}
+function allowed(tool, consent) {
+	if (tool === "googleAnalytics") return consent.analytics;
+	if (tool === "metaPixel") return consent.marketing;
+	return consent.analytics && consent.marketing;
+}
+function withdraw(consent) {
+	if (window.gtag) window.gtag("consent", "update", googleConsent(consent));
+	if (loaded.has("metaPixel") && !consent.marketing) metaPixel()("consent", "revoke");
+	location.reload();
+}
+function load(settings, consent) {
+	if ([...loaded].some((tool) => !allowed(tool, consent))) return withdraw(consent);
+	const pending = TOOLS.filter((tool) => settings[tool] !== null && allowed(tool, consent) && !loaded.has(tool));
+	if (window.gtag || pending.includes("googleAnalytics") || pending.includes("googleTagManager")) gtag()("consent", "update", googleConsent(consent));
+	for (const tool of pending) loaded.add(tool);
+	if (settings.googleAnalytics !== null && pending.includes("googleAnalytics")) {
+		gtag()("js", /* @__PURE__ */ new Date());
+		gtag()("config", settings.googleAnalytics, { send_page_view: false });
+		script(document.head, { src: `https://www.googletagmanager.com/gtag/js?id=${encodeURIComponent(settings.googleAnalytics)}` });
+	}
+	if (settings.googleTagManager !== null && pending.includes("googleTagManager")) {
+		(window.dataLayer ??= []).push({
+			"gtm.start": Date.now(),
+			event: "gtm.js"
+		});
+		script(document.head, { src: `https://www.googletagmanager.com/gtm.js?id=${encodeURIComponent(settings.googleTagManager)}` });
+	}
+	if (settings.metaPixel !== null && pending.includes("metaPixel")) metaPixel()("init", settings.metaPixel);
+	if (settings.scripts !== null && pending.includes("scripts")) {
+		if (settings.scripts.head !== null) script(document.head, { text: settings.scripts.head });
+		if (settings.scripts.bodyEnd !== null) script(document.body, { text: settings.scripts.bodyEnd });
+	}
+}
+function contents(params, currency) {
+	const { items } = params;
+	return {
+		content_type: "product",
+		content_ids: items.map((item) => item.item_id),
+		contents: items.map((item) => ({
+			id: item.item_id,
+			quantity: item.quantity ?? 1,
+			item_price: item.price
+		})),
+		num_items: items.reduce((sum, item) => sum + (item.quantity ?? 1), 0),
+		value: params.value,
+		currency: params.currency ?? currency
+	};
+}
+function sendMeta(event, currency) {
+	const name = META_EVENTS[event.name];
+	if (name === void 0) return;
+	const pixel = metaPixel();
+	if (event.name === "page_view") pixel("track", name);
+	else if (event.name === "search") pixel("track", name, { search_string: event.params.search_term });
+	else if (event.name === "purchase") pixel("track", name, contents(event.params, currency), { eventID: event.params.transaction_id });
+	else if ("value" in event.params) pixel("track", name, contents(event.params, currency));
+}
+function send(settings, consent, event) {
+	const params = "items" in event.params ? {
+		currency: settings.currency,
+		...event.params
+	} : event.params;
+	if (loaded.has("googleAnalytics") && allowed("googleAnalytics", consent)) gtag()("event", event.name, params);
+	if (loaded.has("googleTagManager") && allowed("googleTagManager", consent)) {
+		const layer = window.dataLayer ??= [];
+		if ("items" in event.params) {
+			layer.push({ ecommerce: null });
+			layer.push({
+				event: event.name,
+				ecommerce: params
+			});
+		} else layer.push({
+			event: event.name,
+			...params
+		});
+	}
+	if (loaded.has("metaPixel") && allowed("metaPixel", consent)) sendMeta(event, settings.currency);
+}
+export { load, send };

package/dist/analytics/events-Dt81tIp1.js

@@ -0,0 +1,102 @@
+// src/analytics/events.ts
+const LIST_LIMIT = 24;
+const SEARCH_LIST = {
+	id: "search",
+	name: "Búsqueda"
+};
+const CATALOG_LIST = {
+	id: "catalog",
+	name: "Catálogo"
+};
+function filled(value) {
+	const trimmed = value?.trim() ?? "";
+	if (trimmed === "") return void 0;
+	return trimmed;
+}
+function itemsValue(items) {
+	const total = items.reduce((sum, item) => sum + item.price * (item.quantity ?? 1), 0);
+	return Math.round(total * 100) / 100;
+}
+function productItem(product) {
+	return {
+		item_id: product.id,
+		item_name: product.name,
+		item_brand: filled(product.brand),
+		item_category: filled(product.category),
+		price: product.price
+	};
+}
+function cartItem(item) {
+	return {
+		item_id: item.productId ?? item.variantId ?? item.id,
+		item_name: item.title,
+		item_variant: filled(item.variantLabel),
+		price: item.unitPrice,
+		quantity: item.quantity
+	};
+}
+function listAnalytics(list, products) {
+	const items = products.slice(0, LIST_LIMIT).map((product, index) => ({
+		...productItem(product),
+		index
+	}));
+	return { events: [{
+		name: "view_item_list",
+		params: {
+			item_list_id: list.id,
+			item_list_name: list.name,
+			items
+		}
+	}] };
+}
+function productAnalytics(product) {
+	return { events: [{
+		name: "view_item",
+		params: {
+			value: product.price,
+			items: [productItem(product)]
+		}
+	}] };
+}
+function categoryAnalytics(category, products) {
+	return listAnalytics({
+		id: category.slug,
+		name: category.name
+	}, products);
+}
+function collectionAnalytics(collection, products) {
+	return listAnalytics({
+		id: collection.slug,
+		name: collection.name
+	}, products);
+}
+function catalogAnalytics(q, products) {
+	if (q === "") return listAnalytics(CATALOG_LIST, products);
+	const list = listAnalytics(SEARCH_LIST, products);
+	return { events: [{
+		name: "search",
+		params: { search_term: q }
+	}, ...list.events] };
+}
+function checkoutAnalytics(cart) {
+	const items = cart.items.map(cartItem);
+	return {
+		events: [{
+			name: "begin_checkout",
+			params: {
+				currency: cart.currencyCode,
+				value: itemsValue(items),
+				items
+			}
+		}],
+		once: `begin_checkout:${cart.id}`
+	};
+}
+function orderAnalytics(order, paid) {
+	if (!paid) return { events: [] };
+	return {
+		events: [],
+		paid: order.id
+	};
+}
+export { cartItem, catalogAnalytics, categoryAnalytics, checkoutAnalytics, collectionAnalytics, itemsValue, orderAnalytics, productAnalytics };

package/dist/analytics/events.d.ts

@@ -0,0 +1,51 @@
+import { CategoryDetail, Collection, CustomerOrderDetail, ProductDetail, ProductSummary, StorefrontCart } from "@ecomiq/core";
+export type AnalyticsItem = {
+  item_id: string;
+  item_name: string;
+  item_variant?: string;
+  item_brand?: string;
+  item_category?: string;
+  price: number;
+  quantity?: number;
+  index?: number;
+};
+export type CommerceParams = {
+  currency?: string;
+  value: number;
+  items: AnalyticsItem[];
+};
+export type AnalyticsEvent = {
+  name: "page_view";
+  params: {
+    page_location: string;
+    page_title: string;
+  };
+} | {
+  name: "search";
+  params: {
+    search_term: string;
+  };
+} | {
+  name: "view_item_list";
+  params: {
+    item_list_id: string;
+    item_list_name: string;
+    items: AnalyticsItem[];
+  };
+} | {
+  name: "view_item" | "add_to_cart" | "remove_from_cart" | "begin_checkout";
+  params: CommerceParams;
+} | {
+  name: "purchase";
+  params: CommerceParams & {
+    transaction_id: string;
+    tax: number;
+    shipping: number;
+  };
+};
+export type PageAnalytics = {
+  events: AnalyticsEvent[];
+  once?: string;
+  paid?: string;
+};
+export declare function catalogAnalytics(q: string, products: ProductSummary[]): PageAnalytics;

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;