@wocart/storefront 0.0.0-stage → 1.0.0

package/dist/endpoints/proxy.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Deep Proxy Endpoint Factory
+ *
+ * Consolidates 8 separate endpoint files into ONE factory function.
+ * Hides: input parsing, validation, CSRF protection, header forwarding,
+ * error normalization, and response formatting.
+ *
+ * Deep module principle: Complex proxy logic concentrated in one place,
+ * giving callers maximum leverage with minimal interface.
+ */
+import type { z } from "zod";
+/**
+ * Astro APIRoute handler type (avoiding direct Astro dependency in types)
+ */
+export type AstroAPIContext = {
+    request: Request;
+    params: Record<string, string | undefined>;
+};
+export type AstroAPIRoute = (context: AstroAPIContext) => Response | Promise<Response>;
+/**
+ * Client function that makes the actual API call to the server.
+ *
+ * On failure, every extra field besides `success` and `error` (e.g.
+ * `code`, `windowSeconds`, `attemptsRemaining`, `terminal`) is forwarded
+ * into the error response body — the storefront UI reads these to render
+ * rate-limit countdowns and attempt counters.
+ */
+export type ProxyClientFn<TInput, TOutput> = (data: TInput, headers?: Record<string, string>) => Promise<{
+    success: true;
+    data: TOutput;
+    [key: string]: unknown;
+} | {
+    success: false;
+    error: string;
+    [key: string]: unknown;
+}>;
+/**
+ * Configuration for creating a proxy endpoint
+ */
+export interface ProxyEndpointConfig<TInput, TOutput> {
+    /** HTTP method: 'GET' or 'POST' */
+    method: "GET" | "POST";
+    /** Client function that calls the server — usually a `StoreClient` method. */
+    client: ProxyClientFn<TInput, TOutput>;
+    /** Input validation schema (optional for GET without query validation) */
+    inputSchema?: z.Schema<TInput>;
+    /**
+     * Query parameter names for GET requests
+     * Example: ['wilayaId'] will extract { wilayaId: '42' } from ?wilayaId=42
+     */
+    queryParams?: string[];
+    /**
+     * Path parameter substitution for dynamic URLs
+     * Example: { wilayaId: 'number' } will parse params.wilayaId as number
+     */
+    pathParams?: Record<string, "string" | "number">;
+    /**
+     * Enable CSRF protection (cross-origin check)
+     * Default: true for POST, false for GET
+     */
+    csrfProtection?: boolean;
+    /**
+     * Forward attribution headers (User-Agent, X-Forwarded-For)
+     * Default: false
+     */
+    forwardAttribution?: boolean;
+    /**
+     * Success status code (default: 200)
+     */
+    successStatus?: number;
+    /**
+     * Status code for upstream failures (default: 502).
+     * Typical choices: 502 for cart/abandoned/otp-send, 422 for otp-verify,
+     * 400 for submit-review.
+     */
+    errorStatus?: number;
+    /**
+     * Shape the success response body (default: `(data) => ({ data })`).
+     * Use when the browser contract carries more than `{data}` — e.g.
+     * `(d) => ({ success: true, data: d })` for cart validation, or
+     * `({ rows, total }) => ({ data: rows, total })` for review pagination.
+     */
+    successBody?: (data: TOutput) => unknown;
+    /**
+     * Return 204 No Content on success instead of JSON
+     * Default: false
+     */
+    noContent?: boolean;
+}
+/**
+ * Create a proxy endpoint handler
+ *
+ * @example
+ * ```ts
+ * // POST endpoint with validation
+ * export const POST = createProxyEndpoint({
+ *   method: 'POST',
+ *   client: validateCart,
+ *   inputSchema: cartSchema,
+ *   csrfProtection: true,
+ * });
+ *
+ * // GET endpoint with path params
+ * export const GET = createProxyEndpoint({
+ *   method: 'GET',
+ *   client: fetchCommunes,
+ *   pathParams: { wilayaId: 'number' },
+ * });
+ * ```
+ */
+export declare function createProxyEndpoint<TInput, TOutput>(config: ProxyEndpointConfig<TInput, TOutput>): AstroAPIRoute;

package/dist/endpoints/proxy.js

@@ -0,0 +1,161 @@
+/**
+ * Deep Proxy Endpoint Factory
+ *
+ * Consolidates 8 separate endpoint files into ONE factory function.
+ * Hides: input parsing, validation, CSRF protection, header forwarding,
+ * error normalization, and response formatting.
+ *
+ * Deep module principle: Complex proxy logic concentrated in one place,
+ * giving callers maximum leverage with minimal interface.
+ */
+import { collectForwardedHeaders } from "../actions.js";
+/**
+ * Create a proxy endpoint handler
+ *
+ * @example
+ * ```ts
+ * // POST endpoint with validation
+ * export const POST = createProxyEndpoint({
+ *   method: 'POST',
+ *   client: validateCart,
+ *   inputSchema: cartSchema,
+ *   csrfProtection: true,
+ * });
+ *
+ * // GET endpoint with path params
+ * export const GET = createProxyEndpoint({
+ *   method: 'GET',
+ *   client: fetchCommunes,
+ *   pathParams: { wilayaId: 'number' },
+ * });
+ * ```
+ */
+export function createProxyEndpoint(config) {
+    const { method, client, inputSchema, queryParams = [], pathParams = {}, csrfProtection = method === "POST", forwardAttribution = false, successStatus = 200, errorStatus = 502, successBody, noContent = false, } = config;
+    return async (context) => {
+        const { request, params } = context;
+        // CSRF Protection: reject cross-origin requests
+        if (csrfProtection && isCrossOrigin(request)) {
+            return jsonResponse({ error: "Cross-origin not allowed" }, 403);
+        }
+        // Parse input based on method
+        let input;
+        try {
+            if (method === "GET") {
+                input = parseGetInput(request, params, queryParams, pathParams);
+            }
+            else {
+                input = await parsePostInput(request);
+            }
+        }
+        catch (error) {
+            return jsonResponse({ error: error instanceof Error ? error.message : "Invalid input" }, 400);
+        }
+        // Validate input with Zod schema
+        if (inputSchema) {
+            const parsed = inputSchema.safeParse(input);
+            if (!parsed.success) {
+                return jsonResponse({ error: "Invalid payload" }, 400);
+            }
+            input = parsed.data;
+        }
+        // Prepare attribution headers
+        const headers = forwardAttribution
+            ? collectForwardedHeaders(request)
+            : undefined;
+        // Call client function
+        let result;
+        try {
+            result = await client(input, headers);
+        }
+        catch (error) {
+            return jsonResponse({ error: error instanceof Error ? error.message : "Upstream request failed" }, errorStatus);
+        }
+        // Handle client errors — forward every diagnostic field the client
+        // attached (code, windowSeconds, attemptsRemaining, terminal, ...)
+        // so the storefront UI can render countdowns and attempt counters.
+        if (!result.success) {
+            const extra = { ...result };
+            delete extra.success;
+            delete extra.error;
+            return jsonResponse({ error: result.error, ...extra }, errorStatus);
+        }
+        // Return success response
+        if (noContent) {
+            return new Response(null, { status: 204 });
+        }
+        const body = successBody ? successBody(result.data) : { data: result.data };
+        return jsonResponse(body, successStatus);
+    };
+}
+/**
+ * Parse GET request input from query params and path params
+ */
+function parseGetInput(request, params, queryParams, pathParams) {
+    const url = new URL(request.url);
+    const input = {};
+    // Extract query parameters
+    for (const key of queryParams) {
+        const value = url.searchParams.get(key);
+        if (value !== null) {
+            input[key] = value;
+        }
+    }
+    // Extract and parse path parameters
+    for (const [key, type] of Object.entries(pathParams)) {
+        const value = params[key];
+        if (!value) {
+            throw new Error(`Missing path parameter: ${key}`);
+        }
+        if (type === "number") {
+            const parsed = Number(value);
+            if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+                throw new Error(`Invalid number for path parameter: ${key}`);
+            }
+            input[key] = parsed;
+        }
+        else {
+            input[key] = value;
+        }
+    }
+    return input;
+}
+/**
+ * Parse POST request JSON body
+ */
+async function parsePostInput(request) {
+    try {
+        return await request.json();
+    }
+    catch {
+        throw new Error("Invalid JSON body");
+    }
+}
+/**
+ * Check if request is cross-origin
+ *
+ * Mirrors Astro Actions' built-in CSRF check:
+ * - Requests without Origin header are allowed (older browsers, curl, server-to-server)
+ * - Requests with matching origin are allowed
+ * - Requests with different origin are rejected
+ */
+function isCrossOrigin(request) {
+    const origin = request.headers.get("Origin");
+    if (!origin)
+        return false;
+    try {
+        return new URL(origin).origin !== new URL(request.url).origin;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Create JSON response
+ */
+function jsonResponse(body, status) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "Content-Type": "application/json" },
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Storefront SDK — public entry point.
+ *
+ * Browser-safe storefront contracts and presentation utilities.
+ *
+ * Server code imports `@wocart/storefront/server` for the API-key client.
+ * Astro server code imports `@wocart/storefront/astro` for proxy and action
+ * adapters. Neither server-only entry point is part of this root surface.
+ *
+ * Internal modules stay reachable only through their intentional entry points.
+ */
+export { formatMoney } from "./utils/money.js";
+export type { MoneyFormatOptions } from "./utils/money.js";
+export { optimizeImage, generateSrcSet, IMAGE_SIZES, getCardImage, getGalleryImage, getThumbnailImage, getHeroImage, getCategoryImage, getLogoImage, createImageHelpers, } from "./utils/image.js";
+export type { ImageHelpers, ImageResizeOptions } from "./utils/image.js";
+export { productImageSource } from "./utils/product-image.js";
+export type { ProductImageSourceInput } from "./utils/product-image.js";
+export { MAX_RESOLVED_PREFILL_LENGTH, PREFILL_TOKENS, stripTrackingParams, truncateAtWordBoundary, resolvePrefillText, buildWhatsAppHref, } from "./whatsapp.js";
+export type { PrefillToken, ResolvePrefillParams } from "./whatsapp.js";
+export { STOREFRONT_ROUTES, showsWidgetOn } from "./routes.js";
+export { servedLanguage } from "./locales.js";
+export { alternateLinks, localeRouting, localizeHref, resolveLocalePath } from "./locale-routing.js";
+export type { LocalePath, LocaleRouting } from "./locale-routing.js";
+export type { StorefrontRoute } from "./routes.js";
+export { createBasketStore, createMemoryStorageAdapter, createLocalStorageAdapter, DEFAULT_BASKET_STORAGE_KEY, toOrderItems, } from "./basket.js";
+export type { BasketStore, BasketStorageAdapter, BasketStoreOptions, BasketListener, } from "./basket.js";
+export { createOtpMachine, createOtpTransport, mapOtpResponse, otpTransportFailure, } from "./otp.js";
+export type { OtpMachine, OtpMachineOptions, OtpFailureContext, OtpResponseOptions, OtpState, OtpStatus, OtpTransport, OtpTransportResult, OtpStateListener, } from "./otp.js";
+export { WILAYAS } from "./data/wilayas.js";
+export { ALGERIA_COMMUNES, communesForWilaya } from "./data/communes.js";
+export type { CommuneTuple } from "./data/communes.js";
+export { normalizeAlgerianPhone, toLocalAlgerianMobile } from "./phone.js";
+export * from "./types.js";
+export * from "./schemas.js";
+export * from "./domain.js";
+export * from "./product-view.js";
+export { getOfferTierView } from "./offer-view.js";
+export type { OfferTierInput, OfferTierView } from "./offer-view.js";
+export { createAbandonedCheckoutTracker } from "./abandoned-checkout.js";
+export type { AbandonedCheckoutPorts, AbandonedCheckoutSnapshot, AbandonedCheckoutStorage, AbandonedCheckoutTracker, } from "./abandoned-checkout.js";
+export { META_CURRENCY, buildMetaAddToCartPayload, buildMetaInitiateCheckoutPayload, buildMetaProductPayload, buildMetaViewContentPayload, createMetaPixelTracker, } from "./meta-tracking.js";
+export type { MetaCartPayload, MetaCatalogPayload, MetaContent, MetaEventName, MetaPixelFunction, MetaPixelOptions, MetaPixelTracker, } from "./meta-tracking.js";

package/dist/index.js

@@ -0,0 +1,30 @@
+/**
+ * Storefront SDK — public entry point.
+ *
+ * Browser-safe storefront contracts and presentation utilities.
+ *
+ * Server code imports `@wocart/storefront/server` for the API-key client.
+ * Astro server code imports `@wocart/storefront/astro` for proxy and action
+ * adapters. Neither server-only entry point is part of this root surface.
+ *
+ * Internal modules stay reachable only through their intentional entry points.
+ */
+export { formatMoney } from "./utils/money.js";
+export { optimizeImage, generateSrcSet, IMAGE_SIZES, getCardImage, getGalleryImage, getThumbnailImage, getHeroImage, getCategoryImage, getLogoImage, createImageHelpers, } from "./utils/image.js";
+export { productImageSource } from "./utils/product-image.js";
+export { MAX_RESOLVED_PREFILL_LENGTH, PREFILL_TOKENS, stripTrackingParams, truncateAtWordBoundary, resolvePrefillText, buildWhatsAppHref, } from "./whatsapp.js";
+export { STOREFRONT_ROUTES, showsWidgetOn } from "./routes.js";
+export { servedLanguage } from "./locales.js";
+export { alternateLinks, localeRouting, localizeHref, resolveLocalePath } from "./locale-routing.js";
+export { createBasketStore, createMemoryStorageAdapter, createLocalStorageAdapter, DEFAULT_BASKET_STORAGE_KEY, toOrderItems, } from "./basket.js";
+export { createOtpMachine, createOtpTransport, mapOtpResponse, otpTransportFailure, } from "./otp.js";
+export { WILAYAS } from "./data/wilayas.js";
+export { ALGERIA_COMMUNES, communesForWilaya } from "./data/communes.js";
+export { normalizeAlgerianPhone, toLocalAlgerianMobile } from "./phone.js";
+export * from "./types.js";
+export * from "./schemas.js";
+export * from "./domain.js";
+export * from "./product-view.js";
+export { getOfferTierView } from "./offer-view.js";
+export { createAbandonedCheckoutTracker } from "./abandoned-checkout.js";
+export { META_CURRENCY, buildMetaAddToCartPayload, buildMetaInitiateCheckoutPayload, buildMetaProductPayload, buildMetaViewContentPayload, createMetaPixelTracker, } from "./meta-tracking.js";

package/dist/locale-routing.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Language-prefixed storefront URLs — Shopify's
+ * subfolders: the primary language keeps today's URLs (`/products/x`), every
+ * other published language lives under its code (`/fr/products/x`), and the
+ * primary has exactly one address (`/ar/products/x` redirects to
+ * `/products/x`).
+ *
+ * Pure functions over the store's own languages (`StoreConfig.lang` and
+ * `StoreConfig.locales`): a theme reads the request's language with
+ * `resolveLocalePath`, builds every internal link with `localizeHref`, and
+ * lists a page's language versions with `alternateLinks` — the counterpart of
+ * Shopify's `request.locale.root_url` and `routes`.
+ */
+import type { StoreConfig } from "./types.js";
+/** The store's languages as URLs need them. */
+export interface LocaleRouting {
+    /** The primary language: the one without a prefix. */
+    readonly primary: string;
+    /** Every published language, primary first. */
+    readonly published: readonly string[];
+}
+export declare function localeRouting(config: Pick<StoreConfig, "lang" | "locales">): LocaleRouting;
+export type LocalePath = 
+/** Serve `pathname` in `locale`. */
+{
+    kind: "page";
+    locale: string;
+    pathname: string;
+}
+/** The primary under a prefix: send the shopper to its one address. */
+ | {
+    kind: "redirect";
+    location: string;
+};
+/**
+ * Which language a request is for, and the path it renders. A first segment
+ * that is a published language other than the primary selects it; the
+ * primary's own prefix redirects; anything else — an unpublished or unknown
+ * code included — is an ordinary path in the primary language, so it renders
+ * or 404s exactly as before.
+ */
+export declare function resolveLocalePath(pathname: string, routing: LocaleRouting): LocalePath;
+/**
+ * An internal link in `locale`: `/products/x` → `/fr/products/x`, `/` → `/fr`.
+ * Left unchanged: the primary language, external and protocol-relative URLs,
+ * fragments, `mailto:`/`tel:`, endpoints and files, and a link that already
+ * carries a language prefix. Query strings and fragments are kept.
+ */
+export declare function localizeHref(href: string, locale: string, routing: LocaleRouting): string;
+/**
+ * Every published language's URL for one page, primary first, plus
+ * `x-default` (the primary) — the `<link rel="alternate" hreflang>` set.
+ * `pathname` is the page's unprefixed path; `origin` makes the URLs absolute,
+ * as search engines require.
+ */
+export declare function alternateLinks(pathname: string, routing: LocaleRouting, origin: string): {
+    hreflang: string;
+    href: string;
+}[];

package/dist/locale-routing.js

@@ -0,0 +1,62 @@
+export function localeRouting(config) {
+    const published = config.locales.map((language) => language.code);
+    return {
+        primary: config.lang,
+        published: published.includes(config.lang) ? published : [config.lang, ...published],
+    };
+}
+/** Paths that are never pages: endpoints, framework internals, files. */
+function isPagePath(pathname) {
+    return !/^\/(?:api|_[^/]*)(?:\/|$)/.test(pathname) && !/\/[^/]*\.[a-z0-9]+$/i.test(pathname);
+}
+/**
+ * Which language a request is for, and the path it renders. A first segment
+ * that is a published language other than the primary selects it; the
+ * primary's own prefix redirects; anything else — an unpublished or unknown
+ * code included — is an ordinary path in the primary language, so it renders
+ * or 404s exactly as before.
+ */
+export function resolveLocalePath(pathname, routing) {
+    const match = /^\/([^/]+)(\/.*)?$/.exec(pathname);
+    const segment = match?.[1];
+    if (segment !== undefined && routing.published.includes(segment)) {
+        const rest = match?.[2] ?? "/";
+        if (segment === routing.primary)
+            return { kind: "redirect", location: rest };
+        return { kind: "page", locale: segment, pathname: rest };
+    }
+    return { kind: "page", locale: routing.primary, pathname };
+}
+/**
+ * An internal link in `locale`: `/products/x` → `/fr/products/x`, `/` → `/fr`.
+ * Left unchanged: the primary language, external and protocol-relative URLs,
+ * fragments, `mailto:`/`tel:`, endpoints and files, and a link that already
+ * carries a language prefix. Query strings and fragments are kept.
+ */
+export function localizeHref(href, locale, routing) {
+    if (locale === routing.primary || !href.startsWith("/") || href.startsWith("//"))
+        return href;
+    const split = /^([^?#]*)(.*)$/.exec(href);
+    const pathname = split[1];
+    const rest = split[2];
+    if (!isPagePath(pathname))
+        return href;
+    const first = /^\/([^/]+)/.exec(pathname)?.[1];
+    if (first !== undefined && routing.published.includes(first))
+        return href;
+    return `/${locale}${pathname === "/" ? "" : pathname}${rest}`;
+}
+/**
+ * Every published language's URL for one page, primary first, plus
+ * `x-default` (the primary) — the `<link rel="alternate" hreflang>` set.
+ * `pathname` is the page's unprefixed path; `origin` makes the URLs absolute,
+ * as search engines require.
+ */
+export function alternateLinks(pathname, routing, origin) {
+    const base = origin.replace(/\/+$/, "");
+    const links = routing.published.map((locale) => ({
+        hreflang: locale,
+        href: `${base}${localizeHref(pathname, locale, routing)}`,
+    }));
+    return [...links, { hreflang: "x-default", href: `${base}${pathname}` }];
+}

package/dist/locales.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Store languages as a storefront receives them.
+ *
+ * The platform's list of supported languages lives on the server, never in
+ * this package: `/store/config` sends each served language's code, name and
+ * text direction, so a language the platform adds reaches every theme without
+ * an SDK release — as Shopify themes read `localization.available_languages`.
+ */
+import type { StoreConfig, StorefrontLanguage } from "./types.js";
+/**
+ * The served language with `code` (the store's primary by default), or `null`
+ * when the store does not serve it — the shape a theme reads `<html dir>` and
+ * a language switcher's labels from.
+ */
+export declare function servedLanguage(config: Pick<StoreConfig, "lang" | "locales">, code?: string): StorefrontLanguage | null;

package/dist/locales.js

@@ -0,0 +1,8 @@
+/**
+ * The served language with `code` (the store's primary by default), or `null`
+ * when the store does not serve it — the shape a theme reads `<html dir>` and
+ * a language switcher's labels from.
+ */
+export function servedLanguage(config, code = config.lang) {
+    return config.locales.find((language) => language.code === code) ?? null;
+}

package/dist/meta-tracking.d.ts

@@ -0,0 +1,34 @@
+import type { BasketLine } from "./domain.js";
+export declare const META_CURRENCY: "DZD";
+export type MetaEventName = "ViewContent" | "AddToCart" | "InitiateCheckout" | "Lead" | "Purchase";
+export interface MetaContent {
+    readonly id: string;
+    readonly quantity: number;
+    readonly item_price: number;
+}
+export interface MetaCatalogPayload {
+    readonly [key: string]: unknown;
+    readonly content_ids: readonly string[];
+    readonly content_type: "product";
+    readonly value: number;
+    readonly currency: typeof META_CURRENCY;
+}
+export interface MetaCartPayload extends MetaCatalogPayload {
+    readonly contents: readonly MetaContent[];
+    readonly num_items: number;
+}
+export interface MetaPixelOptions {
+    readonly eventID?: string;
+}
+export type MetaPixelFunction = (...args: unknown[]) => void;
+export interface MetaPixelTracker {
+    track(eventName: MetaEventName, params: Record<string, unknown>): void;
+    trackSingle(pixelId: string, eventName: MetaEventName | string, params: Record<string, unknown>, options?: MetaPixelOptions): void;
+}
+export declare function createMetaPixelTracker(options: {
+    readonly getPixel: () => MetaPixelFunction | null;
+}): MetaPixelTracker;
+export declare function buildMetaProductPayload(productId: string, value: number): MetaCatalogPayload;
+export declare function buildMetaViewContentPayload(productId: string, value: number): MetaCatalogPayload;
+export declare function buildMetaAddToCartPayload(lines: readonly BasketLine[]): MetaCartPayload | null;
+export declare function buildMetaInitiateCheckoutPayload(lines: readonly BasketLine[], value: number): MetaCartPayload | null;

package/dist/meta-tracking.js

@@ -0,0 +1,72 @@
+export const META_CURRENCY = "DZD";
+export function createMetaPixelTracker(options) {
+    return {
+        track(eventName, params) {
+            options.getPixel()?.("track", eventName, params);
+        },
+        trackSingle(pixelId, eventName, params, eventOptions) {
+            if (!pixelId)
+                return;
+            const pixel = options.getPixel();
+            if (!pixel)
+                return;
+            if (eventOptions) {
+                pixel("trackSingle", pixelId, eventName, params, eventOptions);
+            }
+            else {
+                pixel("trackSingle", pixelId, eventName, params);
+            }
+        },
+    };
+}
+function contentsOf(lines) {
+    return lines.map((line) => ({
+        id: line.productId,
+        quantity: line.quantity,
+        item_price: line.unitPrice,
+    }));
+}
+function idsOf(lines) {
+    return [...new Set(lines.map((line) => line.productId))];
+}
+function countOf(lines) {
+    return lines.reduce((total, line) => total + line.quantity, 0);
+}
+function subtotalOf(lines) {
+    return lines.reduce((total, line) => total + line.unitPrice * line.quantity, 0);
+}
+export function buildMetaProductPayload(productId, value) {
+    return {
+        content_ids: [productId],
+        content_type: "product",
+        value,
+        currency: META_CURRENCY,
+    };
+}
+export function buildMetaViewContentPayload(productId, value) {
+    return buildMetaProductPayload(productId, value);
+}
+export function buildMetaAddToCartPayload(lines) {
+    if (lines.length === 0)
+        return null;
+    return {
+        content_ids: idsOf(lines),
+        content_type: "product",
+        contents: contentsOf(lines),
+        num_items: countOf(lines),
+        value: subtotalOf(lines),
+        currency: META_CURRENCY,
+    };
+}
+export function buildMetaInitiateCheckoutPayload(lines, value) {
+    if (lines.length === 0)
+        return null;
+    return {
+        content_ids: idsOf(lines),
+        content_type: "product",
+        contents: contentsOf(lines),
+        num_items: countOf(lines),
+        value,
+        currency: META_CURRENCY,
+    };
+}