@ecomiq/storefront 2.1.4 → 3.0.1

package/dist/public-pages.d.ts

@@ -0,0 +1,67 @@
+import { RouterContextProvider } from "react-router";
+import { PublicOrderTracking } from "@ecomiq/core";
+export type GeoPlace = {
+  code: string;
+  name: string;
+};
+export type ReviewActionData = {
+  ok: boolean;
+  error: string | null;
+};
+export declare function loadGeo(request: Request, context: Readonly<RouterContextProvider>): Promise<{
+  departments: GeoPlace[];
+  provinces: GeoPlace[];
+  districts: GeoPlace[];
+}>;
+export declare function loadSearchSuggestions(request: Request, context: Readonly<RouterContextProvider>): Promise<{
+  q: string;
+  products: never[] | {
+    id: string;
+    name: string;
+    slug: string;
+    url: string;
+    imageUrl: string;
+  }[];
+}>;
+export type TrackingData = {
+  code: string;
+  tracking: PublicOrderTracking | null;
+  missing: boolean;
+  language: string;
+  timeZone: string;
+};
+export declare function loadTracking(request: Request, context: Readonly<RouterContextProvider>, code: string | undefined): Promise<TrackingData>;
+export declare function loadReview(context: Readonly<RouterContextProvider>, token: string): Promise<{
+  review: {
+    orderId: string;
+    orderNumber: string;
+    customerName: string | null;
+    email: string | null;
+    deliveredAt: string | null;
+    items: {
+      productId: string;
+      title: string;
+      variantTitle: string | null;
+      thumbnail: string | null;
+    }[];
+  };
+}>;
+export declare function reviewAction(request: Request, context: Readonly<RouterContextProvider>, token: string): Promise<import("react-router").UNSAFE_DataWithResponseInit<ReviewActionData> | {
+  ok: true;
+  error: null;
+}>;
+export declare function productReviewAction(request: Request, context: Readonly<RouterContextProvider>): Promise<import("react-router").UNSAFE_DataWithResponseInit<ReviewActionData> | {
+  ok: true;
+  error: null;
+}>;
+export type StorefrontPageData = {
+  title: string;
+  html: string;
+  layout: string;
+  seo: {
+    title: string;
+    description: string;
+  };
+};
+export declare function readPage(context: Readonly<RouterContextProvider>, handle: string): Promise<StorefrontPageData | null>;
+export declare function loadPage(context: Readonly<RouterContextProvider>, handle: string): Promise<StorefrontPageData>;

package/dist/registration-CpDcv8ql.js

@@ -0,0 +1,91 @@
+import { safeNext, text } from "./form-BtQcbXlJ.js";
+import { rejectCrossOriginAction, rejectCustomerCsrf } from "./request-security-CRsRMgwj.js";
+import { customer, customerHeaders } from "./session-CKvmFJyg.js";
+import { store } from "./store-8Q-_LFrQ.js";
+import { worker } from "./worker-CNi-gzCu.js";
+import { data, redirect } from "react-router";
+import { ApiError, CustomerRegistrationInputSchema } from "@ecomiq/core";
+// src/registration.ts
+const PRIVATE_HEADERS = {
+	"Cache-Control": "private, no-store",
+	"Referrer-Policy": "no-referrer"
+};
+const FIELDS = [
+	"firstName",
+	"lastName",
+	"phone",
+	"dateOfBirth"
+];
+async function registrationToday(context) {
+	const settings = await store(context).getSettings();
+	return new Intl.DateTimeFormat("en-CA", {
+		timeZone: settings.store.timeZone,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit"
+	}).format(/* @__PURE__ */ new Date());
+}
+async function registrationData(registration, next, context, error = null, status = 200) {
+	const settings = await store(context).getSettings();
+	return data({
+		registration,
+		next,
+		storeName: settings.store.name,
+		error,
+		today: await registrationToday(context)
+	}, {
+		status,
+		headers: PRIVATE_HEADERS
+	});
+}
+/** The session exists at this stage; profile completion must not guard its own route. */
+async function loadCustomerRegistration(request, context) {
+	const next = safeNext(new URL(request.url).searchParams.get("next"));
+	const current = await customer(request, context);
+	if (!current) return redirect(`/account/login?next=${encodeURIComponent(next)}`, { headers: PRIVATE_HEADERS });
+	const registration = await store(context).getCustomerRegistration(customerHeaders(current));
+	if (!registration.requiresCompletion) return redirect(next, { headers: PRIVATE_HEADERS });
+	return registrationData(registration, next, context);
+}
+async function submitCustomerRegistration(request, context) {
+	const rejected = rejectCrossOriginAction(request) ?? await rejectCustomerCsrf(request, context.get(worker).env);
+	if (rejected) return rejected;
+	const next = safeNext(new URL(request.url).searchParams.get("next"));
+	const current = await customer(request, context);
+	if (!current) return redirect(`/account/login?next=${encodeURIComponent(next)}`, {
+		status: 303,
+		headers: PRIVATE_HEADERS
+	});
+	const client = store(context);
+	const options = customerHeaders(current);
+	const registration = await client.getCustomerRegistration(options);
+	if (!registration.requiresCompletion) return redirect(next, {
+		status: 303,
+		headers: PRIVATE_HEADERS
+	});
+	const form = await request.formData();
+	const skip = text(form, "intent") === "skip";
+	const input = {};
+	for (const field of FIELDS) if (!skip && registration.fields[field] !== "hidden") input[field] = text(form, field) || null;
+	const submitted = {
+		...registration,
+		...input
+	};
+	const parsed = CustomerRegistrationInputSchema.safeParse(input);
+	if (!parsed.success) return registrationData(submitted, next, context, "Revisa los datos ingresados y vuelve a intentar.", 400);
+	for (const field of FIELDS) if (registration.fields[field] === "required" && !submitted[field]?.trim()) return registrationData(submitted, next, context, "Completa los datos obligatorios para continuar.", 400);
+	if (input.dateOfBirth && input.dateOfBirth > await registrationToday(context)) return registrationData(submitted, next, context, "La fecha de nacimiento no puede ser futura.", 400);
+	try {
+		const completed = await client.completeCustomerRegistration(parsed.data, options);
+		if (completed.requiresCompletion) return registrationData(completed, next, context, "Completa los datos obligatorios para continuar.", 400);
+		return redirect(next, {
+			status: 303,
+			headers: PRIVATE_HEADERS
+		});
+	} catch (error) {
+		let message = "No pudimos guardar tus datos. Intenta de nuevo.";
+		if (error instanceof ApiError && error.status === 400) message = error.message;
+		return registrationData(submitted, next, context, message, 400);
+	}
+}
+export { loadCustomerRegistration, submitCustomerRegistration };

package/dist/registration.d.ts

@@ -0,0 +1,12 @@
+import { RouterContextProvider, data } from "react-router";
+import { CustomerRegistration } from "@ecomiq/core";
+export type CustomerRegistrationData = {
+  registration: CustomerRegistration;
+  storeName: string;
+  next: string;
+  error: string | null;
+  today: string;
+};
+/** The session exists at this stage; profile completion must not guard its own route. */
+export declare function loadCustomerRegistration(request: Request, context: Readonly<RouterContextProvider>): Promise<Response | ReturnType<typeof data<CustomerRegistrationData>>>;
+export declare function submitCustomerRegistration(request: Request, context: Readonly<RouterContextProvider>): Promise<Response | ReturnType<typeof data<CustomerRegistrationData>>>;

package/dist/request-security-CRsRMgwj.js

@@ -0,0 +1,76 @@
+import { base64Url, base64UrlBytes, customerSessionId, equalSecret } from "./customer-cookies-DHOgFAMV.js";
+import { PRIVATE_STOREFRONT_SUBTREES } from "@ecomiq/core/redirects";
+// src/request-security.ts
+const SAFE_METHODS = /* @__PURE__ */ new Set([
+	"GET",
+	"HEAD",
+	"OPTIONS"
+]);
+const PRIVATE_PATH = new RegExp(`^/(${PRIVATE_STOREFRONT_SUBTREES.join("|")})(/|$)`);
+async function sessionCsrfToken(sessionId, env) {
+	const encoder = new TextEncoder();
+	const key = await crypto.subtle.importKey("raw", encoder.encode(env.SESSION_SECRET), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(`customer-csrf\n${env.ECOMIQ_STORE}\n${sessionId}`));
+	return base64Url(new Uint8Array(signature));
+}
+async function customerCsrfTokenForRequest(request, env) {
+	const sessionId = await customerSessionId(request, env);
+	return sessionId ? sessionCsrfToken(sessionId, env) : "";
+}
+async function rejectCustomerCsrf(request, env) {
+	if (SAFE_METHODS.has(request.method)) return null;
+	const sessionId = await customerSessionId(request, env);
+	if (!sessionId) return null;
+	let submitted = request.headers.get("X-Customer-Csrf");
+	if (!submitted) try {
+		submitted = (await request.clone().formData()).get("__customer_csrf");
+	} catch {
+		submitted = null;
+	}
+	const expected = await sessionCsrfToken(sessionId, env);
+	if (typeof submitted === "string" && equalSecret(submitted, expected)) return null;
+	return new Response("La sesión cambió. Recarga la página antes de continuar.", {
+		status: 403,
+		headers: {
+			"Cache-Control": "private, no-store",
+			"Content-Type": "text/plain; charset=utf-8"
+		}
+	});
+}
+/** Browser actions must originate on the storefront that owns the cookies. */
+function rejectCrossOriginAction(request) {
+	if (SAFE_METHODS.has(request.method)) return null;
+	if (request.headers.get("Origin") === new URL(request.url).origin && request.headers.get("Sec-Fetch-Site") !== "cross-site") return null;
+	return new Response("La solicitud debe enviarse desde esta tienda. Recarga la página e intenta de nuevo.", {
+		status: 403,
+		headers: {
+			"Cache-Control": "private, no-store",
+			"Content-Type": "text/plain; charset=utf-8"
+		}
+	});
+}
+function privateCustomerResponse(request) {
+	const path = new URL(request.url).pathname;
+	return !SAFE_METHODS.has(request.method) || PRIVATE_PATH.test(path) || /(?:^|;\s*)(?:__Host-ecomiq-customer|cart)=/.test(request.headers.get("Cookie") ?? "");
+}
+async function customerClientHeaders(request, env, target) {
+	const address = request.headers.get("CF-Connecting-IP");
+	const store = env.ECOMIQ_STORE_ID;
+	if (!address || !store || !env.CUSTOMER_IP_KEY) return {};
+	const timestamp = String(Math.floor(Date.now() / 1e3));
+	const key = await crypto.subtle.importKey("raw", base64UrlBytes(env.CUSTOMER_IP_KEY), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	const signature = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(`${timestamp}\n${store}\n${address}\nPOST\n${target.pathname}`));
+	return {
+		"X-Ecomiq-Client-Ip": address,
+		"X-Ecomiq-Client-Store": store,
+		"X-Ecomiq-Client-Timestamp": timestamp,
+		"X-Ecomiq-Client-Signature": base64Url(new Uint8Array(signature))
+	};
+}
+export { customerClientHeaders, customerCsrfTokenForRequest, privateCustomerResponse, rejectCrossOriginAction, rejectCustomerCsrf };

package/dist/rich-text-M-Ju8RL4.js

@@ -0,0 +1,9 @@
+import { jsx } from "react/jsx-runtime";
+// src/rich-text.tsx
+function RichText({ html, className }) {
+	return /* @__PURE__ */ jsx("div", {
+		className,
+		dangerouslySetInnerHTML: { __html: html }
+	});
+}
+export { RichText };

package/dist/rich-text.d.ts

@@ -0,0 +1,5 @@
+import { ReactElement } from "react";
+export declare function RichText({ html, className }: {
+  html: string;
+  className?: string;
+}): ReactElement;

package/dist/route-text-DcJw2SsK.js

@@ -0,0 +1,9 @@
+import { storefrontText } from "./storefront-text-D25ae1qf.js";
+import { z } from "zod";
+// src/route-text.ts
+const RootLanguage = z.object({ shop: z.object({ translations: z.record(z.string(), z.string()).default({}) }) });
+function storefrontRouteText(matches, source) {
+	const root = RootLanguage.safeParse(matches.find((match) => match?.id === "root")?.data);
+	return storefrontText(root.success ? root.data.shop.translations : {}, source);
+}
+export { storefrontRouteText };

package/dist/route-text.d.ts

@@ -0,0 +1,4 @@
+export declare function storefrontRouteText(matches: readonly ({
+  id: string;
+  data?: unknown;
+} | undefined)[], source: string): string;

package/dist/section-preview-CmsMl3yu.js

@@ -0,0 +1,83 @@
+import { loadSections, withSections } from "./sections-CNUMWTF_.js";
+import { worker } from "./worker-CNi-gzCu.js";
+import { data, useLoaderData } from "react-router";
+import { createElement, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+// src/section-preview.tsx
+const COMPONENT = /^[A-Z][A-Za-z0-9]*$/;
+const DESIGN = {
+	file: "@ecomiq/storefront/sections/design-system",
+	component: "DesignSystem"
+};
+const rendered = /* @__PURE__ */ new Map();
+function notFound() {
+	throw data(null, { status: 404 });
+}
+function sectionFile(path) {
+	return `app/${path.replace(/^(?:\.\.\/)+/, "")}`;
+}
+function sectionEntries(module) {
+	const load = module.load;
+	if (typeof load !== "function") return [];
+	const section = load.section;
+	if (typeof section !== "string") return [];
+	return [{
+		section,
+		load,
+		props: {}
+	}];
+}
+async function sectionPreview(args, modules) {
+	const { env } = args.context.get(worker);
+	if (env.ECOMIQ_PREVIEW !== "1") notFound();
+	const url = new URL(args.request.url);
+	if (url.searchParams.get("design") === "1") {
+		const design = await import(
+			/* @vite-ignore */
+			DESIGN.file
+);
+		rendered.set(DESIGN.file, design);
+		return DESIGN;
+	}
+	const file = url.searchParams.get("file") ?? "";
+	const component = url.searchParams.get("component") ?? "";
+	const path = Object.keys(modules).find((candidate) => sectionFile(candidate) === file);
+	const importer = path === void 0 ? void 0 : modules[path];
+	if (importer === void 0 || !COMPONENT.test(component)) notFound();
+	const module = await importer();
+	if (typeof module[component] !== "function") notFound();
+	rendered.set(file, module);
+	const pending = loadSections(args, sectionEntries(module));
+	const sections = Object.fromEntries(await Promise.all(Object.entries(pending).map(async ([key, value]) => [key, await value])));
+	return withSections({
+		file,
+		component
+	}, sections);
+}
+function sectionPreviewMeta() {
+	return [{
+		name: "robots",
+		content: "noindex"
+	}];
+}
+function serverHtml(component) {
+	if (typeof document === "undefined") return "";
+	return document.querySelector(`[data-ecomiq-preview="${CSS.escape(component)}"]`)?.innerHTML ?? "";
+}
+function SectionPreview() {
+	const { file, component } = useLoaderData();
+	const [html] = useState(() => serverHtml(component));
+	const Section = rendered.get(file)?.[component];
+	if (typeof Section !== "function") return /* @__PURE__ */ jsx("div", {
+		"data-ecomiq-preview": component,
+		style: { display: "flow-root" },
+		suppressHydrationWarning: true,
+		dangerouslySetInnerHTML: { __html: html }
+	});
+	return /* @__PURE__ */ jsx("div", {
+		"data-ecomiq-preview": component,
+		style: { display: "flow-root" },
+		children: createElement(Section)
+	});
+}
+export { SectionPreview, sectionPreview, sectionPreviewMeta };

package/dist/section-preview.d.ts

@@ -0,0 +1,12 @@
+import { LoaderFunctionArgs, MetaDescriptor } from "react-router";
+import { ReactElement } from "react";
+export type SectionModules = {
+  readonly [path: string]: () => Promise<unknown>;
+};
+export type SectionPreviewData = {
+  readonly file: string;
+  readonly component: string;
+};
+export declare function sectionPreview(args: LoaderFunctionArgs, modules: SectionModules): Promise<SectionPreviewData>;
+export declare function sectionPreviewMeta(): MetaDescriptor[];
+export declare function SectionPreview(): ReactElement;

package/dist/sections/account-addresses.d.ts

@@ -0,0 +1,18 @@
+import { AddressActionData } from "../account.js";
+import "../index.js";
+import { SectionCatalog } from "../settings.js";
+import "../entries/account.js";
+import { CustomerAddress } from "@ecomiq/core";
+export declare const catalog: SectionCatalog;
+type Country = {
+  code: string;
+  name: string;
+};
+export declare function AccountAddresses({ loaderData, actionData }: {
+  loaderData: {
+    addresses: CustomerAddress[];
+    countries: Country[];
+  };
+  actionData?: AddressActionData;
+}): import("react").JSX.Element;
+export {};