@asstio-dev/storefront 0.31.1 → 0.40.0-market.1

package/dist/account/next.js

@@ -18,10 +18,7 @@ async function context(config) {
     const jar = await cookies();
     const security = cookieSecurity(config.origin);
     const shopperIp = shopperIpFrom(await headers(), { trustedHops: config.trustedHops });
-    const client = (session) => createShopperClient({
-        baseUrl: config.baseUrl, serverKey: config.serverKey, market: config.market, acceptLanguage: config.acceptLanguage,
-        session, shopperIp, fetch: config.fetch,
-    });
+    const client = (session) => createShopperClient({ ...config, session, shopperIp });
     return { jar, security, client };
 }
 const set = (jar, spec) => jar.set(spec);
@@ -50,6 +47,9 @@ function keepCarts(jar, config, security, data, current) {
 function withoutData(r, view) {
     return r.ok ? { ok: true, data: view(r.data) } : r;
 }
+function transition(r) {
+    return r.ok ? { ok: true, data: signedInView(r.data), dropPrivateData: true } : r;
+}
 /**
  * Starts a sign-in: `POST /v1/auth/sign-in`, then the binding (with the challenge id) goes into the sign-in cookie for 10
  * minutes. An unsafe `returnPath` is dropped here as the API would. The result carries the challenge id for the code form.
@@ -64,8 +64,9 @@ export async function startSignInAction(config, email, returnPath) {
 }
 /**
  * Verifies a code or link with the binding from the sign-in cookie: on success the session cookie is set (to the session's
- * absolute expiry) and the sign-in cookie cleared. `409 SIGN_IN_CONFIRM_REQUIRED` comes back as a problem with
- * `maskedEmail` and `siteName`; ask the shopper, then call again with `confirm: true`.
+ * absolute expiry), the sign-in cookie cleared, and the result says `dropPrivateData: true`: the guest's cart view goes, and an adopted
+ * cart is read again. `409 SIGN_IN_CONFIRM_REQUIRED` comes back as a problem with `maskedEmail` and `siteName`; ask the shopper, then
+ * call again with `confirm: true`.
  */
 export async function verifySignInAction(config, input) {
     const { jar, security, client } = await context(config);
@@ -83,12 +84,13 @@ export async function verifySignInAction(config, input) {
         set(jar, signInCookie.clear(security));
         keepCarts(jar, config, security, r.data, cartToken);
     }
-    return withoutData(r, signedInView);
+    return transition(r);
 }
 /**
- * Switches the principal: the rotated token replaces the session cookie at once (the old one serves GETs for 30 s only).
- * A failure (also `SESSION_INVALID`) is returned and leaves the cookie alone: a switch that lost to a concurrent one from
- * another tab would otherwise delete the winner's fresh cookie. Refresh the session state; only `signOutAction` clears.
+ * Switches the principal: the rotated token replaces the session cookie at once (the old one serves GETs for 30 s only), the
+ * cart cookie moves to the new principal's own cart, and the result says `dropPrivateData: true`. A failure (also `SESSION_INVALID`)
+ * is returned and leaves the cookie alone: a switch that lost to a concurrent one from another tab would otherwise delete the
+ * winner's fresh cookie. Refresh the session state; only `signOutAction` clears.
  */
 export async function switchPrincipalAction(config, principal) {
     const { jar, security, client } = await context(config);
@@ -99,22 +101,23 @@ export async function switchPrincipalAction(config, principal) {
         // The old principal keeps its cart; the new principal's cart becomes the cart cookie, or the cookie is cleared when it has none.
         keepCarts(jar, config, security, r.data, config.cartCookie ? read(jar, config.cartCookie) : null);
     }
-    return withoutData(r, signedInView);
+    return transition(r);
 }
 /**
  * Signs out (`everywhere` ends every session of the account). The session cookie, the sign-in cookie, the cart cookie and the
  * browser-cart cookie are cleared whatever the API answered, and also when it cannot be reached (`{ ok: false, status: 0, problem.code: "NETWORK" }`)
- * — a session already gone is still a sign-out for this browser.
+ * — a session already gone is still a sign-out for this browser. So every answer says `dropPrivateData: true`.
  */
 export async function signOutAction(config, opts = {}) {
     const { jar, security, client } = await context(config);
     const token = session(jar, security);
     try {
-        return token ? await signOut(client(token), opts) : { ok: true, data: undefined };
+        const result = token ? await signOut(client(token), opts) : { ok: true, data: undefined };
+        return { ...result, dropPrivateData: true };
     }
     catch {
         // Spec §7.8: an unreachable API still signs this browser out; the session ends server-side at its idle expiry.
-        return localFailure("NETWORK", "The API could not be reached; this browser is signed out.");
+        return { ...localFailure("NETWORK", "The API could not be reached; this browser is signed out."), dropPrivateData: true };
     }
     finally {
         set(jar, sessionCookie.clear(security));

package/dist/analytics/decimal.d.ts

@@ -5,9 +5,13 @@ export type Rational = {
 };
 /** `"125.00"`, `"25"`, `"-3.5"` → an exact rational. Anything else (exponents, commas, blanks) throws. */
 export declare function parseDecimal(s: string): Rational;
-/** The net of a VAT-inclusive amount: `gross / (1 + rate / 100)`, exactly. */
+/** The net of a VAT-inclusive amount: `gross / (1 + rate / 100)`, exactly. For checkout and order lines only, which have no price pair
+ * yet (WP9b, WP10); a pair's `ex` is read, never computed. */
 export declare function netOf(gross: Rational, vatRatePercent: Rational): Rational;
 export declare function add(a: Rational, b: Rational): Rational;
-/** Rounded to whole cents (öre), half away from zero. */
+/** The nearest number to an exact amount, as `Number("1.234")` reads it: reduced first, because a sum's denominator can outgrow a float. */
+export declare function toNumber(r: Rational): number;
+/** Rounded to whole cents (öre), half away from zero. For checkout and order amounts only, which are two-decimal until WP9b and WP10;
+ * a pair keeps the precision the API sent it in, the currency's own. */
 export declare function toCents(r: Rational): bigint;
 export declare const centsToNumber: (cents: bigint) => number;

package/dist/analytics/decimal.js

@@ -9,14 +9,22 @@ export function parseDecimal(s) {
     const n = BigInt(whole + fraction);
     return { n: negative ? -n : n, d: 10n ** BigInt(fraction.length) };
 }
-/** The net of a VAT-inclusive amount: `gross / (1 + rate / 100)`, exactly. */
+/** The net of a VAT-inclusive amount: `gross / (1 + rate / 100)`, exactly. For checkout and order lines only, which have no price pair
+ * yet (WP9b, WP10); a pair's `ex` is read, never computed. */
 export function netOf(gross, vatRatePercent) {
     return { n: gross.n * 100n * vatRatePercent.d, d: gross.d * (100n * vatRatePercent.d + vatRatePercent.n) };
 }
 export function add(a, b) {
     return { n: a.n * b.d + b.n * a.d, d: a.d * b.d };
 }
-/** Rounded to whole cents (öre), half away from zero. */
+const gcd = (a, b) => (b === 0n ? a : gcd(b, a % b));
+/** The nearest number to an exact amount, as `Number("1.234")` reads it: reduced first, because a sum's denominator can outgrow a float. */
+export function toNumber(r) {
+    const divisor = gcd(r.n < 0n ? -r.n : r.n, r.d);
+    return Number(r.n / divisor) / Number(r.d / divisor);
+}
+/** Rounded to whole cents (öre), half away from zero. For checkout and order amounts only, which are two-decimal until WP9b and WP10;
+ * a pair keeps the precision the API sent it in, the currency's own. */
 export function toCents(r) {
     const num = r.n * 100n;
     let q = num / r.d; // truncates toward zero

package/dist/analytics/ga4.d.ts

@@ -1,8 +1,9 @@
+import { type Rational } from "./decimal.js";
 import { type CartDto, type CategoryRefDto, type CheckoutCartDto, type Ga4Ecommerce, type Ga4Item, type Ga4ItemOptions, type Ga4ItemSource, type Ga4Purchase, type Ga4SharedOptions, type OrderDto } from "./types.js";
-/** An item and its unit price in cents, so a payload's `value` sums exact cents rather than re-reading floats. */
+/** An item and its exact unit price, so a payload's `value` sums exact amounts rather than re-reading floats. */
 export type MappedItem = {
     item: Ga4Item;
-    priceCents: bigint;
+    unitPrice: Rational;
 };
 /**
  * One GA4 item from a card (an impression: the family sku and from-price), a product with its selected variant, a cart
@@ -13,8 +14,9 @@ export declare function toGa4Item(source: Ga4ItemSource, opts?: Ga4ItemOptions):
 export declare function mapItem(source: Ga4ItemSource, opts?: Ga4ItemOptions): MappedItem;
 /**
  * A whole GA4 payload: `{ currency, value, items }` for a cart; plus `transaction_id`, `tax` and `shipping` for an order
- * (`purchase`). Each line keeps its own quantity and id; `index` is its position. Only product lines are items.
- * `value` is the sum of the emitted items' rounded prices × quantities, not gross minus tax. An order's `tax` is its
+ * (`purchase`). Each line keeps its own quantity and id; `index` is its position. Only product lines are items, and of a cart only the
+ * lines its context still sells: an `unavailable` cart line (market model §13: no longer covered there) has no price and is no item.
+ * `value` is the sum of the emitted items' prices × quantities, exactly, not gross minus tax. An order's `tax` is its
  * recorded VAT and its `shipping` comes from its shipping lines, each netted at its own rate and rounded once.
  */
 export declare function toGa4Ecommerce(source: CartDto, opts?: Ga4SharedOptions): Ga4Ecommerce;

package/dist/analytics/ga4.js

@@ -1,4 +1,4 @@
-import { add, centsToNumber, netOf, parseDecimal, toCents } from "./decimal.js";
+import { add, centsToNumber, netOf, parseDecimal, toCents, toNumber } from "./decimal.js";
 import { productFacts } from "./facts.js";
 import { AnalyticsError, } from "./types.js";
 /**
@@ -13,8 +13,8 @@ export function mapItem(source, opts = {}) {
     const line = lineOf(source);
     const facts = productFacts(source);
     const quantity = opts.quantity === undefined ? line.quantity : checkedQuantity(opts.quantity);
-    const priceCents = toCents(opts.tax === "include" ? line.gross : netOf(line.gross, line.vatRate));
-    const item = { item_id: opts.itemId ?? line.id, item_name: line.name, price: centsToNumber(priceCents), quantity };
+    const unitPrice = amountOf(line, opts.tax);
+    const item = { item_id: opts.itemId ?? line.id, item_name: line.name, price: toNumber(unitPrice), quantity };
     if (facts.brand)
         item.item_brand = facts.brand.label;
     const variant = itemVariant(line.options);
@@ -33,19 +33,21 @@ export function mapItem(source, opts = {}) {
         item.item_list_id = opts.itemListId;
     if (opts.itemListName !== undefined)
         item.item_list_name = opts.itemListName;
-    return { item, priceCents };
+    return { item, unitPrice };
 }
 export function toGa4Ecommerce(source, opts = {}) {
     const isOrder = "totals" in source && "reference" in source;
-    const lines = isOrder ? source.lines.filter(l => l.type === "product") : source.lines;
+    const lines = isOrder
+        ? source.lines.filter(l => l.type === "product")
+        : source.lines.filter(l => l.availability !== "unavailable");
     // Only the shared options: an options object that also carries item overrides (quantity, itemId, index) must never
     // rewrite every line's identity or quantity.
     const shared = {
         tax: opts.tax, affiliation: opts.affiliation, itemListId: opts.itemListId, itemListName: opts.itemListName, pickCategory: opts.pickCategory,
     };
     const mapped = lines.map((l, index) => mapItem(l, { ...shared, index }));
-    const valueCents = mapped.reduce((sum, m) => sum + m.priceCents * BigInt(m.item.quantity), 0n);
-    const payload = { currency: source.currency, value: centsToNumber(valueCents), items: mapped.map(m => m.item) };
+    const value = mapped.reduce((sum, m) => add(sum, { n: m.unitPrice.n * BigInt(m.item.quantity), d: m.unitPrice.d }), { n: 0n, d: 1n });
+    const payload = { currency: source.currency, value: toNumber(value), items: mapped.map(m => m.item) };
     if (!isOrder)
         return payload;
     const order = source;
@@ -63,29 +65,47 @@ function lineOf(source) {
         const l = source;
         if (l.type !== "product")
             throw new AnalyticsError(`an order line of type "${l.type}" is not an item`);
-        return { id: l.sku, name: l.name, gross: parseDecimal(l.unitPriceInc), vatRate: parseDecimal(l.vatRate), quantity: sourceQuantity(l.quantity), options: l.options };
+        return { id: l.sku, name: l.name, ...grossMoney(l.unitPriceInc, l.vatRate), quantity: sourceQuantity(l.quantity), options: l.options };
     }
     if (typeof s.unitPriceInc === "string" && typeof s.productId === "string" && typeof s.type !== "string") {
-        // A checkout cart line: the snapshot's own amounts (`unitPriceInc`, `vatRate`), not a PriceDto, and the options on the line.
+        // A checkout cart line: the snapshot's own amounts (`unitPriceInc`, `vatRate`), not a price pair, and the options on the line.
         const l = source;
-        return { id: l.sku, name: l.name, gross: parseDecimal(l.unitPriceInc), vatRate: parseDecimal(l.vatRate), quantity: sourceQuantity(l.quantity), options: l.options };
+        return { id: l.sku, name: l.name, ...grossMoney(l.unitPriceInc, l.vatRate), quantity: sourceQuantity(l.quantity), options: l.options };
     }
     if (typeof s.variant === "object" && s.variant !== null && "selectedOptions" in s.variant) {
         if ("quantity" in s) {
+            // A cart line: its unit pair in the cart's context (market model §8.1), as a card's — never a computed amount.
             const l = source;
-            return { id: l.sku, name: l.product.name, ...money(l.price), quantity: sourceQuantity(l.quantity), options: l.variant.selectedOptions };
+            return { id: l.sku, name: l.product.name, ...pairMoney(l.unitPrice, `cart line ${l.sku}`), quantity: sourceQuantity(l.quantity), options: l.variant.selectedOptions };
         }
+        // A selected variant: its own offer's pair in the response's context (market model §8.2), like a card's.
         const { product, variant } = source;
-        if (!variant.price)
-            throw new AnalyticsError(`variant ${variant.sku} has no price on this market`);
-        return { id: variant.sku, name: product.name, ...money(variant.price), quantity: 1, options: variant.selectedOptions };
+        return { id: variant.sku, name: product.name, ...pairMoney(variant.offer.price, `variant ${variant.sku}`), quantity: 1, options: variant.selectedOptions };
     }
+    // A card: its from-price pair on the response's price basis (market model §8.2), never a computed amount.
     const c = source;
-    if (!c.price)
-        throw new AnalyticsError(`product ${c.sku} has no price on this market`);
-    return { id: c.sku, name: c.name, ...money(c.price), quantity: 1, options: null };
+    return { id: c.sku, name: c.name, ...pairMoney(c.priceFrom?.price, `product ${c.sku}`), quantity: 1, options: null };
+}
+/** A pair's own sides; a partial pair (market model M35) lacks one, and an unpriced one both, which throws. */
+function pairMoney(pair, what) {
+    if (!pair?.inc && !pair?.ex)
+        throw new AnalyticsError(`${what} has no price here`);
+    return { gross: pair.inc ? parseDecimal(pair.inc) : null, net: pair.ex ? parseDecimal(pair.ex) : null };
+}
+const toTwoDecimals = (r) => ({ n: toCents(r), d: 100n });
+/** A checkout or order line's gross, and its net at the line's rate, each rounded to two decimals. */
+function grossMoney(inc, vatRate) {
+    const gross = parseDecimal(inc);
+    return { gross: toTwoDecimals(gross), net: toTwoDecimals(netOf(gross, parseDecimal(vatRate))) };
+}
+/** The line's amount for the tax option; the side a partial price lacks throws. */
+function amountOf(line, tax) {
+    const include = tax === "include";
+    const amount = include ? line.gross : line.net;
+    if (amount === null)
+        throw new AnalyticsError(`${line.id} has no price ${include ? "with" : "without"} tax (a partial price); map it with tax: "${include ? "exclude" : "include"}"`);
+    return amount;
 }
-const money = (p) => ({ gross: parseDecimal(p.amount), vatRate: parseDecimal(p.vatRate) });
 /** The generated quantity is `number | string`. */
 function sourceQuantity(q) {
     const n = typeof q === "number" ? q : Number(q);

package/dist/analytics/types.d.ts

@@ -12,7 +12,7 @@ export type CheckoutCartLineDto = Schemas["CheckoutCartLineDto"];
 export type BrandDto = Schemas["BrandDto"];
 export type CategoryRefDto = Schemas["CategoryRefDto"];
 export type AttributeDto = Schemas["AttributeDto"];
-export type PriceDto = Schemas["PriceDto"];
+export type PricePairDto = Schemas["PricePairDto"];
 /** A product page with the variant the shopper selected. */
 export type SelectedVariant = {
     product: ProductDto;

package/dist/checkout/types.d.ts

@@ -6,7 +6,7 @@ export type CheckoutWidgetDto = components["schemas"]["CheckoutWidgetDto"];
 export type CheckoutShippingViewDto = components["schemas"]["CheckoutShippingViewDto"];
 export type OrderDto = components["schemas"]["OrderDto"];
 export type StartCheckoutRequest = components["schemas"]["StartCheckoutRequest"];
-/** The problem body; `cart` is the corrected cart on 409 CHECKOUT_CART_CHANGED (an extension, so it is typed loosely here). */
+/** The problem body; `cart` is the corrected cart on 409 CHECKOUT_CART_CHANGED and the cart as stored on 409 CONTEXT_MISMATCH (an extension, so it is typed loosely here). */
 export type StorefrontProblem = components["schemas"]["StorefrontProblem"] & {
     cart?: unknown;
 };
@@ -20,6 +20,17 @@ export type CheckoutResult = {
     problem: StorefrontProblem;
     retryAfter?: number;
 };
+/** `409 CONTEXT_MISMATCH` from `POST /v1/checkout`: the request's `X-Market` or `X-Country` is not the cart's stored market or country. The
+ * message names the cart's and `problem.cart` is the cart; only `POST /v1/cart/context` moves it. */
+export type CheckoutContextMismatchError = Extract<CheckoutResult, {
+    ok: false;
+}> & {
+    status: 409;
+    problem: StorefrontProblem & {
+        code: "CONTEXT_MISMATCH";
+    };
+};
+export declare function isCheckoutContextMismatch(result: CheckoutResult): result is CheckoutContextMismatchError;
 export type StatusResult = {
     ok: true;
     data: CheckoutStatusDto;

package/dist/checkout/types.js

@@ -1,3 +1,6 @@
+export function isCheckoutContextMismatch(result) {
+    return !result.ok && result.status === 409 && result.problem.code === "CONTEXT_MISMATCH";
+}
 /** `Retry-After` in seconds: a delay, or an HTTP-date turned into one; garbage is 1 s, absence is undefined. */
 export function retryAfterSeconds(response, now = Date.now) {
     const raw = response.headers.get("Retry-After");

package/dist/context.d.ts

@@ -0,0 +1,23 @@
+import type { components } from "./schema";
+export type BindingDto = components["schemas"]["BindingDto"];
+/**
+ * The commerce context of a client (market model §6.1, §18.5), fixed for the client's life: a page binding from `GET /v1/site`
+ * (`bindings[]`), or the values one by one. Each one left out is left to the API (§6.2): market → the only market or the default
+ * binding's, country → the market's only or default one, locale → the country's default.
+ */
+export type CommerceContextOptions = {
+    /** Market code, e.g. "eur". */
+    market?: string;
+    /** ISO country, e.g. "DE". Needed to create a cart or check out on a market with several countries. */
+    country?: string;
+    /** Locale tag as the site spells it, e.g. "sv". */
+    locale?: string;
+    binding?: never;
+} | {
+    binding: BindingDto;
+    market?: never;
+    country?: never;
+    locale?: never;
+};
+/** The context headers of a client, read once: what the caller's options object does later changes nothing. */
+export declare function commerceHeaders(context: CommerceContextOptions): readonly (readonly [string, string])[];

package/dist/context.js

@@ -0,0 +1,6 @@
+/** The context headers of a client, read once: what the caller's options object does later changes nothing. */
+export function commerceHeaders(context) {
+    const { market, country, locale } = context.binding ?? context;
+    const headers = [["X-Market", market], ["X-Country", country], ["X-Locale", locale]];
+    return headers.filter((h) => Boolean(h[1]));
+}

package/dist/filters.d.ts

@@ -1,3 +1,6 @@
+import type { components } from "./schema";
+type FacetDto = components["schemas"]["FacetDto"];
+type PriceBasisDto = components["schemas"]["PriceBasisDto"];
 /**
  * The list grammar of a `filter[<key>]` parameter (list, swatch and hierarchy facets): `,` separates values, `\,` is a
  * comma inside a value and `\\` a backslash. A value key is the raw value — an option such as "14,2" is the key "14,2" —
@@ -10,3 +13,10 @@ export declare function encodeFilterValues(values: readonly string[]): string;
  * before anything else (or at the end) kept as it is, values trimmed, empty ones and repeats dropped.
  */
 export declare function decodeFilterValues(param: string): string[];
+/**
+ * The basis a price facet's bounds — and a `filter[price]` built from them — are stated on: the request context's display
+ * basis (`inc` or `ex`) and currency, which the API sets on the price facet only. A slider labels itself from this ("excl.
+ * VAT, SEK" for a dealer, "incl. VAT, EUR" for a consumer) rather than assuming a basis; null for any other facet.
+ */
+export declare function priceFacetBasis(facet: FacetDto): PriceBasisDto | null;
+export {};

package/dist/filters.js

@@ -37,3 +37,11 @@ export function decodeFilterValues(param) {
     push();
     return values;
 }
+/**
+ * The basis a price facet's bounds — and a `filter[price]` built from them — are stated on: the request context's display
+ * basis (`inc` or `ex`) and currency, which the API sets on the price facet only. A slider labels itself from this ("excl.
+ * VAT, SEK" for a dealer, "incl. VAT, EUR" for a consumer) rather than assuming a basis; null for any other facet.
+ */
+export function priceFacetBasis(facet) {
+    return facet.range !== null && facet.priceBasis ? facet.priceBasis : null;
+}

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 import { type Client } from "openapi-fetch";
 import type { paths } from "./schema";
+import { type CommerceContextOptions } from "./context.js";
 export type { paths, components } from "./schema";
+export type { BindingDto, CommerceContextOptions } from "./context.js";
 /**
  * The API requires X-Site-Key on every call, so the generated types demand `params.header` at every call site —
- * but this client sets all three headers itself. These map the generated paths to the same operations with the
+ * but this client sets the key and the commerce context itself. These map the generated paths to the same operations with the
  * header block optional: the contract stays honest, and the caller does not repeat the key on every request.
  */
 type HeadersOptional<Params> = Omit<Params, "header"> & (Params extends {
@@ -22,18 +24,15 @@ export type StorefrontPaths = {
         } : paths[Path][Method];
     };
 };
-export interface StorefrontClientOptions {
+export type StorefrontClientOptions = {
     /** e.g. https://api.storefront.asstio.com */
     baseUrl: string;
     /** publishable (browser), preview (draft mode) or secret (server only) site key */
     siteKey: string;
-    /** market code, e.g. "se"; omit for the site's default market */
-    market?: string;
-    /** BCP-47 tag; omit to use the market's language */
-    acceptLanguage?: string;
     fetch?: typeof fetch;
-}
-/** Thin typed client: every call carries X-Site-Key / X-Market / Accept-Language. Works in browsers and on the server. */
+} & CommerceContextOptions;
+/** Thin typed client: every call carries X-Site-Key and the context (X-Market / X-Country / X-Locale) fixed here: one client per context.
+ * Works in browsers and on the server. */
 export declare function createStorefrontClient(opts: StorefrontClientOptions): Client<StorefrontPaths>;
 /** The `filter` query parameter of a listing call: one facet key to one value, as the generated types spell it. */
 export type FilterSelection = NonNullable<NonNullable<paths["/v1/products"]["get"]["parameters"]["query"]>["filter"]>;
@@ -45,16 +44,19 @@ export type FilterSelection = NonNullable<NonNullable<paths["/v1/products"]["get
  * The client sends it as `filter[brand]=dior,chanel` (deepObject), which is what the API reads.
  */
 export declare function filterQuery(selection: Record<string, string | string[] | undefined>): FilterSelection;
-export { decodeFilterValues, encodeFilterValues } from "./filters.js";
+export { decodeFilterValues, encodeFilterValues, priceFacetBasis } from "./filters.js";
 export { coverOffset, fileUrl, fillFactor, formatFactor, formatImage, imageRect, mediaHash, mediaUrl, MediaUrlError, pickWidth, pictureSources, posterUrl, scaledSizes, srcSet, styleToCss, videoSources, type FormatFit, type FormattedImage, type MediaConfig, type MediaDescriptor, type MediaFormat, type PictureSources, type SlotSize, type VideoSource, } from "./media.js";
 export { awaitCompletion, completeCheckout, getCheckoutStatus, getOrder, liveShippingFor, startCheckout, syncCheckout, type CheckoutClient, type ShopperOption, type StartCheckoutOptions, type SyncRetryOptions, type AwaitCompletionOptions } from "./checkout/server.js";
-export { retryAfterSeconds, type CheckoutDto, type CheckoutOrderRefDto, type CheckoutResult, type CheckoutShippingViewDto, type LiveShippingResult, type CheckoutStatusDto, type CheckoutWidgetDto, type OrderDto, type OrderResult, type StatusResult, type StorefrontProblem } from "./checkout/types.js";
+export { isCheckoutContextMismatch, retryAfterSeconds, type CheckoutContextMismatchError, type CheckoutDto, type CheckoutOrderRefDto, type CheckoutResult, type CheckoutShippingViewDto, type LiveShippingResult, type CheckoutStatusDto, type CheckoutWidgetDto, type OrderDto, type OrderResult, type StatusResult, type StorefrontProblem } from "./checkout/types.js";
 export { mountCheckout, type CheckoutHandle, type MountOptions, type MinimalDocument, type MinimalElement, type MinimalScript } from "./checkout/browser.js";
 export { controllers, type CheckoutController, type ProviderWindow } from "./checkout/controllers.js";
+export { displayPrice, isBuyable, isPriceVisible, type DisplayPrice, type OfferDto } from "./offer.js";
 export { breadcrumbJsonLd } from "./seo/breadcrumb.js";
 export { brandHead, collectionHead, productHead, toNextMetadata } from "./seo/head.js";
 export { gtinJsonLd } from "./gtin.js";
+export { hreflangFor } from "./seo/locales.js";
 export { productJsonLd } from "./seo/product.js";
+export { requireBinding } from "./seo/shared.js";
 export { sitemapEntries, toNextSitemap, type NextSitemapEntry, type SitemapOptions, type SitemapResult, type SitemapType, type SitemapUrl } from "./seo/sitemap.js";
 export { jsonLdScript } from "./seo/serialize.js";
 export { productFacts } from "./analytics/facts.js";

package/dist/index.js

@@ -1,15 +1,16 @@
 import createClient from "openapi-fetch";
+import { commerceHeaders } from "./context.js";
 import { encodeFilterValues } from "./filters.js";
-/** Thin typed client: every call carries X-Site-Key / X-Market / Accept-Language. Works in browsers and on the server. */
+/** Thin typed client: every call carries X-Site-Key and the context (X-Market / X-Country / X-Locale) fixed here: one client per context.
+ * Works in browsers and on the server. */
 export function createStorefrontClient(opts) {
     const client = createClient({ baseUrl: opts.baseUrl.replace(/\/$/, ""), fetch: opts.fetch });
+    const context = commerceHeaders(opts);
     const headers = {
         onRequest({ request }) {
             request.headers.set("X-Site-Key", opts.siteKey);
-            if (opts.market)
-                request.headers.set("X-Market", opts.market);
-            if (opts.acceptLanguage)
-                request.headers.set("Accept-Language", opts.acceptLanguage);
+            for (const [name, value] of context)
+                request.headers.set(name, value);
             return request;
         },
     };
@@ -34,16 +35,19 @@ export function filterQuery(selection) {
     }
     return out;
 }
-export { decodeFilterValues, encodeFilterValues } from "./filters.js";
+export { decodeFilterValues, encodeFilterValues, priceFacetBasis } from "./filters.js";
 export { coverOffset, fileUrl, fillFactor, formatFactor, formatImage, imageRect, mediaHash, mediaUrl, MediaUrlError, pickWidth, pictureSources, posterUrl, scaledSizes, srcSet, styleToCss, videoSources, } from "./media.js";
 export { awaitCompletion, completeCheckout, getCheckoutStatus, getOrder, liveShippingFor, startCheckout, syncCheckout } from "./checkout/server.js"; // SyncRetryOptions *(plan review 3 #5)*
-export { retryAfterSeconds } from "./checkout/types.js";
+export { isCheckoutContextMismatch, retryAfterSeconds } from "./checkout/types.js";
 export { mountCheckout } from "./checkout/browser.js";
 export { controllers } from "./checkout/controllers.js";
+export { displayPrice, isBuyable, isPriceVisible } from "./offer.js";
 export { breadcrumbJsonLd } from "./seo/breadcrumb.js";
 export { brandHead, collectionHead, productHead, toNextMetadata } from "./seo/head.js";
 export { gtinJsonLd } from "./gtin.js";
+export { hreflangFor } from "./seo/locales.js";
 export { productJsonLd } from "./seo/product.js";
+export { requireBinding } from "./seo/shared.js";
 export { sitemapEntries, toNextSitemap } from "./seo/sitemap.js";
 export { jsonLdScript } from "./seo/serialize.js";
 export { productFacts } from "./analytics/facts.js";

package/dist/offer.d.ts

@@ -0,0 +1,16 @@
+import type { components } from "./schema";
+export type OfferDto = components["schemas"]["OfferDto"];
+/** One amount to show, on the basis the API chose for this context. */
+export type DisplayPrice = {
+    amount: string;
+    basis: "inc" | "ex";
+    currency: string;
+};
+/** The amount to show (market model §8.2): the offer's `displayBasis` side of its pair, as the API sent it. Null when the offer is not
+ * `available`, or when the pair lacks that side: never the other side, and never a computed amount. */
+export declare function displayPrice(offer: OfferDto): DisplayPrice | null;
+/** Whether a price can be shown: a partial price can be, and still not be buyable. */
+export declare function isPriceVisible(offer: OfferDto): boolean;
+/** Whether the buy button works: the offer is `available` and so is its `purchaseStatus`, which already folds in permission, freshness,
+ * sellability and a complete price. Never read stock or the price for this. */
+export declare function isBuyable(offer: OfferDto): boolean;

package/dist/offer.js

@@ -0,0 +1,17 @@
+/** The amount to show (market model §8.2): the offer's `displayBasis` side of its pair, as the API sent it. Null when the offer is not
+ * `available`, or when the pair lacks that side: never the other side, and never a computed amount. */
+export function displayPrice(offer) {
+    if (offer.offerStatus !== "available")
+        return null;
+    const amount = offer.price?.[offer.displayBasis];
+    return amount ? { amount, basis: offer.displayBasis, currency: offer.price.currency } : null;
+}
+/** Whether a price can be shown: a partial price can be, and still not be buyable. */
+export function isPriceVisible(offer) {
+    return displayPrice(offer) !== null;
+}
+/** Whether the buy button works: the offer is `available` and so is its `purchaseStatus`, which already folds in permission, freshness,
+ * sellability and a complete price. Never read stock or the price for this. */
+export function isBuyable(offer) {
+    return offer.offerStatus === "available" && offer.purchaseStatus === "available";
+}