@webround/commerce 0.0.0-stage → 0.3.0

package/dist/checkout/store.js

@@ -0,0 +1,179 @@
+import { canonicalJson } from '../canonical.js';
+import { CommerceError, toCommerceError } from '../errors.js';
+import { createStateHolder } from '../store-kit.js';
+import { CHECKOUT_ERROR_CODES } from './types.js';
+/** The checkout before anything is chosen (new objects each time: a state is never changed in place). */
+const noChoices = () => ({
+    deliveryMethods: {},
+    shippingAddress: null,
+    billingAddress: null,
+    shippingMethodId: null,
+    promotionCodes: [],
+    additionalData: null,
+    email: '',
+    requestsInvoice: false,
+    invoiceVatCode: null,
+    invoiceRecipientCode: null,
+});
+export function createCheckoutStore(options) {
+    const { api, cart } = options;
+    /** What the preview asks for these choices and these lines: only what the store reads, and only what there is. */
+    function quoteBodyOf(choices, lines) {
+        const deliveryMethods = {};
+        for (const line of lines) {
+            const method = choices.deliveryMethods[line.variantId];
+            if (method !== undefined)
+                deliveryMethods[line.variantId] = method;
+        }
+        return {
+            langCode: options.langCode?.() ?? 'default',
+            cartItems: lines.map((l) => ({ variantId: l.variantId, priceId: l.priceId, quantity: l.quantity })),
+            deliveryMethods,
+            ...(choices.promotionCodes.length > 0 ? { promotionCodes: choices.promotionCodes } : {}),
+            ...(choices.shippingMethodId !== null ? { shippingMethodId: choices.shippingMethodId } : {}),
+            ...(choices.shippingAddress !== null ? { shippingAddress: choices.shippingAddress } : {}),
+            ...(choices.billingAddress !== null ? { billingAddress: choices.billingAddress } : {}),
+            ...(choices.additionalData !== null ? { additionalData: choices.additionalData } : {}),
+        };
+    }
+    // Who is asking is part of the question: the store prices a logged-in customer by what it knows of them (a VAT exemption, for one)
+    const keyOf = (body) => canonicalJson({ owner: cart.getState().owner, body });
+    const currentLines = () => cart.getState().lines;
+    const holder = createStateHolder({
+        ...noChoices(),
+        quote: null,
+        requestKey: keyOf(quoteBodyOf(noChoices(), currentLines())),
+        quotedKey: null,
+        isStale: false,
+        lineCount: currentLines().length,
+        quoting: false,
+        paying: false,
+        error: null,
+    });
+    /** Changes the state and, in the same change, what the preview would ask now and whether the one on show still answers it. */
+    function change(patch) {
+        const next = { ...holder.get(), ...patch };
+        const lines = currentLines();
+        const requestKey = keyOf(quoteBodyOf(next, lines));
+        holder.set({ ...patch, requestKey, lineCount: lines.length, isStale: next.quote !== null && next.quotedKey !== requestKey });
+    }
+    /** Everything chosen and the preview, forgotten; a preview on its way is cancelled. */
+    function reset() {
+        attempt++;
+        inflight?.abort();
+        inflight = null;
+        attemptedKey = null;
+        change({ ...noChoices(), quote: null, quotedKey: null, error: null, quoting: false });
+    }
+    // Which preview is the last one asked: an answer that is not the last is thrown away
+    let attempt = 0;
+    let inflight = null;
+    let stopFollowing = null;
+    // What the preview was last asked, by whoever asked: `ensureQuote` does not ask the same question twice, so any number of components can use it, and a refusal is not asked again by itself
+    let attemptedKey = null;
+    const superseded = () => new CommerceError({ kind: 'aborted', message: 'A newer preview was asked for.' });
+    const store = {
+        getState: holder.get,
+        subscribe: holder.subscribe,
+        start() {
+            if (stopFollowing)
+                return;
+            let known = canonicalJson({ owner: cart.getState().owner, lines: currentLines() });
+            stopFollowing = cart.subscribe(() => {
+                const now = canonicalJson({ owner: cart.getState().owner, lines: currentLines() });
+                if (now === known)
+                    return;
+                known = now;
+                change({});
+            });
+            change({});
+        },
+        setDeliveryMethod: (variantId, method) => change({ deliveryMethods: { ...holder.get().deliveryMethods, [variantId]: method } }),
+        setShippingAddress: (address) => change({ shippingAddress: address }),
+        setBillingAddress: (address) => change({ billingAddress: address }),
+        selectShippingMethod: (id) => change({ shippingMethodId: id }),
+        setPromotionCodes: (codes) => change({ promotionCodes: [...codes] }),
+        setAdditionalData: (data) => change({ additionalData: data }),
+        setEmail: (email) => change({ email }),
+        setInvoice: (invoice) => change({ requestsInvoice: invoice.requested, invoiceVatCode: invoice.vatCode ?? null, invoiceRecipientCode: invoice.recipientCode ?? null }),
+        async quote(callOptions) {
+            const body = quoteBodyOf(holder.get(), currentLines());
+            const key = keyOf(body);
+            attemptedKey = key;
+            const mine = ++attempt;
+            inflight?.abort();
+            const controller = new AbortController();
+            inflight = controller;
+            // The caller's own way of giving up cancels this one too
+            const onCallerAbort = () => controller.abort();
+            callOptions?.signal?.addEventListener('abort', onCallerAbort, { once: true });
+            holder.set({ quoting: true });
+            try {
+                const answer = await api.quote({ ...body, cartTrackingId: options.trackingId() }, { signal: controller.signal });
+                if (mine !== attempt)
+                    throw superseded();
+                change({ quote: answer, quotedKey: key, error: null });
+                return answer;
+            }
+            catch (error) {
+                const failure = toCommerceError(error);
+                // What a newer question made useless is not a failure of the checkout
+                if (mine === attempt && failure.kind !== 'aborted')
+                    holder.set({ error: failure });
+                throw failure;
+            }
+            finally {
+                callOptions?.signal?.removeEventListener('abort', onCallerAbort);
+                if (mine === attempt) {
+                    inflight = null;
+                    holder.set({ quoting: false });
+                }
+            }
+        },
+        async ensureQuote() {
+            const { lineCount, requestKey } = holder.get();
+            if (lineCount === 0 || requestKey === attemptedKey)
+                return null;
+            return store.quote();
+        },
+        async pay(returnUrls) {
+            const state = holder.get();
+            // A line the last preview said is unavailable is never sent to the payment (the store would refuse it): what is paid is what can be bought. A page pays with a fresh preview; the store's own refusal
+            // (the last unit sold between the preview and the payment) is what is left, and the page asks for the preview again.
+            const unavailable = new Set(state.quote?.unavailable.map((l) => l.variantId) ?? []);
+            const all = currentLines();
+            const lines = all.filter((l) => !unavailable.has(l.variantId));
+            if (all.length > 0 && lines.length === 0) {
+                throw new CommerceError({ kind: 'http', status: 400, code: CHECKOUT_ERROR_CODES.nothingToPay, message: 'Nothing in the cart can be bought: every line is unavailable.' });
+            }
+            const invoice = state.requestsInvoice
+                ? { requestsInvoice: true, invoiceVatCode: state.invoiceVatCode ?? '', invoiceRecipientCode: state.invoiceRecipientCode ?? '' }
+                : { invoiceVatCode: state.invoiceVatCode, invoiceRecipientCode: state.invoiceRecipientCode };
+            const urls = returnUrls ?? options.returnUrls?.() ?? {};
+            // The payment needs a delivery method for every line: the customer's choice, and for a line they did not choose for, the one the preview gave it (its default)
+            const given = Object.fromEntries((state.quote?.items ?? []).flatMap((i) => (lines.some((l) => l.variantId === i.variantId) ? [[i.variantId, i.deliveryMethod]] : [])));
+            const input = { ...quoteBodyOf({ ...state, deliveryMethods: { ...given, ...state.deliveryMethods } }, lines), cartTrackingId: options.trackingId(), ...urls, ...invoice, email: state.email };
+            holder.set({ paying: true });
+            try {
+                return await api.pay(input);
+            }
+            catch (error) {
+                throw toCommerceError(error);
+            }
+            finally {
+                holder.set({ paying: false });
+            }
+        },
+        reset,
+        async complete() {
+            await options.clearCart();
+            reset();
+        },
+        dispose() {
+            stopFollowing?.();
+            stopFollowing = null;
+        },
+    };
+    return store;
+}
+//# sourceMappingURL=store.js.map

package/dist/checkout/types.d.ts

@@ -0,0 +1,225 @@
+import type { CartLineInput } from '../cart/types.js';
+import type { AddressInput } from '../addresses/types.js';
+/** How a line reaches the customer: they pick it up (`pickup`), it is shipped (`shipping`), or there is nothing to deliver (`none`, a digital product). Chosen for each VARIANT in the cart. */
+export declare const DELIVERY_METHODS: readonly ["pickup", "shipping", "none"];
+export type DeliveryMethod = (typeof DELIVERY_METHODS)[number];
+/**
+ * An address for a checkout: what the checkout takes for `shippingAddress` and `billingAddress`, in the same shape everywhere (here, in the checkout state, in the store). It is an address of the address book without its
+ * id and without the "default" flags. `fullName` is at least 2 characters, `addressLine1` 3, `postalCode` 3, `countryCode` the two letters of the country (`IT`): the store checks it, not this package.
+ */
+export type CheckoutAddress = Omit<AddressInput, 'isDefaultShipping' | 'isDefaultBilling'>;
+/** What the preview (`quote`) asks. Nothing in it is a total: the store works out every figure. */
+export interface QuoteInput {
+    /** The language the store answers in (`default` for the store's own). */
+    langCode: string;
+    /** The lines of the cart: ONE for each variant (a variant twice is refused), 1 to 10000 each. */
+    cartItems: CartLineInput[];
+    /** How each variant of the cart reaches the customer, by the variant's id. One for each variant. */
+    deliveryMethods: Record<string, DeliveryMethod>;
+    /** The codes the customer typed (up to 10). */
+    promotionCodes?: string[];
+    /** The shipping method the customer chose, from `Quote.shipping.options`; absent = not chosen yet. */
+    shippingMethodId?: string;
+    shippingAddress?: CheckoutAddress;
+    billingAddress?: CheckoutAddress;
+    requestsInvoice?: boolean;
+    /** Webround Commerce's own id of this cart (the same for a guest and for the customer they become). */
+    cartTrackingId?: string;
+    /** What the site wants kept with the order: free-form, the store's hooks may add to it. */
+    additionalData?: Record<string, unknown> | null;
+}
+/** Where the customer comes back to after paying or giving up. Both or neither: the store refuses one alone, and their origins must be the store's, an allowed one or localhost. */
+export type ReturnUrls = {
+    successUrl: string;
+    cancelUrl: string;
+} | {
+    successUrl?: undefined;
+    cancelUrl?: undefined;
+};
+/** An invoice: when one is asked for, the store needs the VAT code (the recipient code is optional); without an invoice both are optional. */
+export type InvoiceInput = {
+    requestsInvoice: true;
+    invoiceVatCode: string;
+    invoiceRecipientCode?: string;
+} | {
+    requestsInvoice?: false;
+    invoiceVatCode?: string | null;
+    invoiceRecipientCode?: string | null;
+};
+/** What starting a payment asks: what the preview asks, who pays (`email`: for a guest it is who the order is for), where they come back to, and the invoice. */
+export type PayInput = Omit<QuoteInput, 'requestsInvoice'> & ReturnUrls & InvoiceInput & {
+    email: string;
+};
+/** What starting a payment gives: the page of the payment provider, to send the customer to, and the order that was made (it is paid when the provider says so, a moment later). */
+export interface PayAnswer {
+    url: string;
+    /** The order the payment is for. */
+    orderId: string;
+    /** The order's number, the one the customer sees (`null` if the store does not number its orders). */
+    reference: number | null;
+}
+/**
+ * What describes a line (the cart page, the checkout, the confirmation show it) and is not part of the price: the preview is the ONE call that prices a cart AND describes it, so a site asks `/cart/total` or the catalog for
+ * nothing else. The names are in the language asked; `options` are the variant's, as the cart has always given them.
+ */
+export interface QuoteLinePresentation {
+    variantName: string;
+    productName: string | null;
+    /** The page of the variant is `/product/<variantSlug>`. */
+    variantSlug: string;
+    skuCode: string | null;
+    coverUrl: string | null;
+    options: {
+        optionName: string;
+        tagValue: string;
+        tagValueAlias: string | null;
+    }[];
+    /** How the product can reach the customer: what the line can choose from (`deliveryMethods` of the request). */
+    allowedDeliveryMethods: DeliveryMethod[];
+    /** Units there are now (not what the line asks). A line that asks for more is in `Quote.unavailable`, unless `allowBackorder`. */
+    availableStock: number;
+    allowBackorder: boolean;
+    /** The most the variant sells in one order. */
+    maxOrderQuantity: number;
+}
+/** A line of the preview, priced: unit and line amounts (each unit rounded first), net, VAT and gross. A line a hook added has `origin: { hookId }`. */
+export interface QuoteLine extends QuoteLinePresentation {
+    variantId: string;
+    productId: string;
+    priceId: string;
+    quantity: number;
+    deliveryMethod: DeliveryMethod;
+    vatRate: number;
+    unitNet: number;
+    unitVat: number;
+    unitGross: number;
+    totalNet: number;
+    totalVat: number;
+    totalGross: number;
+    origin: 'cart' | {
+        hookId: string;
+    };
+}
+export type QuoteDiscountSource = {
+    type: 'promotion';
+    id: string;
+    code?: string;
+} | {
+    type: 'hook';
+    hookId: string;
+};
+export type QuoteDiscountTarget = 'order' | {
+    variantIds: string[];
+} | {
+    shippingMethodId: string;
+};
+/**
+ * A line of the preview that cannot be bought because there is not enough of it (no backorder): it is NOT an error of the preview. It is priced like the others but without discounts, and it is left out of `items`, `totals`,
+ * the promotions, the shipping and the hooks. The whole line is unavailable even if some units exist (5 asked, 3 there): `availableStock` says how many there are, `quantity` is what was asked. The payment never takes it
+ * (`CheckoutStore.pay` does not send it, and the store answers 400 if it ever gets one).
+ */
+export interface QuoteUnavailableLine extends QuoteLinePresentation {
+    variantId: string;
+    productId: string;
+    priceId: string;
+    /** What was asked (`availableStock` is what there is now: 0 for none). */
+    quantity: number;
+    deliveryMethod: DeliveryMethod;
+    vatRate: number;
+    unitNet: number;
+    unitVat: number;
+    unitGross: number;
+    totalNet: number;
+    totalVat: number;
+    totalGross: number;
+}
+/** A discount that was applied, on the net, already worked out (never below zero). */
+export interface QuoteDiscount {
+    source: QuoteDiscountSource;
+    label?: string;
+    class: 'product' | 'order' | 'shipping';
+    target: QuoteDiscountTarget;
+    amount: number;
+}
+/** A shipping option the customer can choose, priced; `grandGrossIfSelected` is what the whole order would cost with it. */
+export interface QuoteShippingOption {
+    id: string;
+    label: string;
+    net: number;
+    vatRate: number;
+    vat: number;
+    gross: number;
+    etaMin?: number | null;
+    etaMax?: number | null;
+    grandGrossIfSelected: number;
+}
+export interface QuoteTotals {
+    net: number;
+    vat: number;
+    gross: number;
+    /** What the discounts took off: the lines' and the chosen shipping's (without a chosen one, only the lines'). */
+    discountTotal: number;
+    shippingNet: number | null;
+    shippingVat: number | null;
+    shippingGross: number | null;
+    grandNet: number;
+    grandVat: number;
+    /** What the customer pays: the lines and the chosen shipping. This is the figure to show, and the one the payment is for. */
+    grandGross: number;
+    /** There is something to ship and no shipping method is chosen yet: the total is without shipping. */
+    shippingPending: boolean;
+}
+/** Why a code that is valid did nothing: no line could take the discount, or it does not apply to this cart (a fixed amount without the cart's currency). Not an error. */
+export declare const PROMOTION_REJECTION_REASONS: readonly ["NO_ELIGIBLE_ITEMS", "NOT_APPLICABLE"];
+export type PromotionRejectionReason = (typeof PROMOTION_REJECTION_REASONS)[number];
+export interface QuotePromotions {
+    /** The codes that discounted something. */
+    applied: string[];
+    /** The valid codes that discounted nothing, and why. */
+    rejected: {
+        code: string;
+        reason: PromotionRejectionReason;
+    }[];
+}
+/** What the preview answers: what the customer would pay for this cart, with the store's rules and hooks applied. The preview changes nothing in the store. */
+export interface Quote {
+    currencyCode: string;
+    /** How the cart is paid: `once`, or the cadence of a subscription (`monthly`, `quarterly`…). A cart has only one: a line with another is refused. */
+    cadence: string;
+    /** The lines that can be bought: the ones `totals` add up. */
+    items: QuoteLine[];
+    /** The lines with not enough stock: priced, but out of `items` and `totals`. */
+    unavailable: QuoteUnavailableLine[];
+    discounts: QuoteDiscount[];
+    shipping: {
+        options: QuoteShippingOption[];
+        selectedId: string | null;
+    };
+    totals: QuoteTotals;
+    promotions: QuotePromotions;
+    additionalData: Record<string, unknown>;
+}
+/** The `code` the checkout gives to what it refuses on purpose (`CommerceError.code`), for the interface to translate. */
+export declare const CHECKOUT_ERROR_CODES: {
+    /** A hook of the store stopped the checkout (`meta`: `{ hookId, code, target }`: the hook's own reason and what it is about). */
+    readonly blocked: "CHECKOUT_BLOCKED";
+    /** A hook of the store that must not fail did (`meta`: `{ hookId, reason }`). */
+    readonly hookFailed: "CHECKOUT_HOOK_FAILED";
+    /** The chosen shipping method is not available for this order (`meta`: `{ shippingMethodId }`). */
+    readonly shippingMethodUnavailable: "SHIPPING_METHOD_UNAVAILABLE";
+    /** Raised here, before asking the store: every line of the cart is one the last preview said is unavailable, so there is nothing to pay for. */
+    readonly nothingToPay: "NOTHING_TO_PAY";
+    /** There is not enough of a variant (`meta`: `{ variantId, requested, available }`). The payment is the one that refuses it: the preview sets such a line aside. */
+    readonly insufficientStock: "INSUFFICIENT_STOCK";
+    /** A subscription (a recurring price) is for a customer who is signed in: a guest cannot buy it. Both the preview and the payment refuse it. */
+    readonly loginRequiredForSubscription: "LOGIN_REQUIRED_FOR_SUBSCRIPTION";
+    /** A subscription is for a customer whose email is verified. */
+    readonly emailNotVerifiedForSubscription: "EMAIL_NOT_VERIFIED_FOR_SUBSCRIPTION";
+    /** More of a variant than one order can have (`meta`: `{ variantId, requested, max }`). */
+    readonly maxQuantityExceeded: "MAX_QUANTITY_EXCEEDED";
+};
+/** What a hook that stopped the checkout points at: the cart as a whole, the address, or a variant. */
+export type CheckoutBlockTarget = 'cart' | 'address' | {
+    variantId: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/checkout/types.js

@@ -0,0 +1,28 @@
+// What the checkout's calls (`/v2/checkout/quote` and `/v2/checkout/stripe`) take and give, as the checkout API says it: the shapes are its own, nothing is renamed, reshaped or completed. Typed as strictly as the API is
+// (a delivery method is one of three words, an invoice's codes come with the invoice), because a mistake that the compiler can see is one the store never has to refuse. The store's `quote` and `pay` are
+// defined by the checkout service of the Commerce Stripe Processor; if it changes, this changes with it.
+/** How a line reaches the customer: they pick it up (`pickup`), it is shipped (`shipping`), or there is nothing to deliver (`none`, a digital product). Chosen for each VARIANT in the cart. */
+export const DELIVERY_METHODS = ['pickup', 'shipping', 'none'];
+/** Why a code that is valid did nothing: no line could take the discount, or it does not apply to this cart (a fixed amount without the cart's currency). Not an error. */
+export const PROMOTION_REJECTION_REASONS = ['NO_ELIGIBLE_ITEMS', 'NOT_APPLICABLE'];
+// ── what the checkout refuses with a code of its own ─────────
+/** The `code` the checkout gives to what it refuses on purpose (`CommerceError.code`), for the interface to translate. */
+export const CHECKOUT_ERROR_CODES = {
+    /** A hook of the store stopped the checkout (`meta`: `{ hookId, code, target }`: the hook's own reason and what it is about). */
+    blocked: 'CHECKOUT_BLOCKED',
+    /** A hook of the store that must not fail did (`meta`: `{ hookId, reason }`). */
+    hookFailed: 'CHECKOUT_HOOK_FAILED',
+    /** The chosen shipping method is not available for this order (`meta`: `{ shippingMethodId }`). */
+    shippingMethodUnavailable: 'SHIPPING_METHOD_UNAVAILABLE',
+    /** Raised here, before asking the store: every line of the cart is one the last preview said is unavailable, so there is nothing to pay for. */
+    nothingToPay: 'NOTHING_TO_PAY',
+    /** There is not enough of a variant (`meta`: `{ variantId, requested, available }`). The payment is the one that refuses it: the preview sets such a line aside. */
+    insufficientStock: 'INSUFFICIENT_STOCK',
+    /** A subscription (a recurring price) is for a customer who is signed in: a guest cannot buy it. Both the preview and the payment refuse it. */
+    loginRequiredForSubscription: 'LOGIN_REQUIRED_FOR_SUBSCRIPTION',
+    /** A subscription is for a customer whose email is verified. */
+    emailNotVerifiedForSubscription: 'EMAIL_NOT_VERIFIED_FOR_SUBSCRIPTION',
+    /** More of a variant than one order can have (`meta`: `{ variantId, requested, max }`). */
+    maxQuantityExceeded: 'MAX_QUANTITY_EXCEEDED',
+};
+//# sourceMappingURL=types.js.map

package/dist/commerce.d.ts

@@ -0,0 +1,55 @@
+import { type Cache } from './cache.js';
+import { type Auth, type AuthConfig } from './auth/auth.js';
+import type { CachedCatalog } from './catalog/cached.js';
+import { type Account } from './account/account.js';
+import { type AddressBook } from './addresses/book.js';
+import { type Reviews } from './reviews/reviews.js';
+import { type Wishlist } from './wishlist/wishlist.js';
+import { type Returns } from './returns/returns.js';
+import { type Orders } from './orders/orders.js';
+import { type KeyValuePort } from './cart/storage.js';
+import { type CartStore } from './cart/store.js';
+import { type CheckoutStore } from './checkout/store.js';
+import type { ReturnUrls } from './checkout/types.js';
+export interface CommerceConfig extends Omit<AuthConfig, 'baseUrl'> {
+    /** The commerce API (customers, cart, checkout), without a trailing slash. */
+    commerceApiUrl: string;
+    /** The catalog API (products, collections, filters), without a trailing slash. */
+    catalogApiUrl: string;
+    /** The checkout API (it prices a cart and starts its payment), without a trailing slash. Without it the store works, and `checkout` fails where it is used, saying so. */
+    checkoutApiUrl?: string;
+    /** Where the customer comes back to after paying (success) or giving up (cancel); the origins must be the store's, an allowed one or localhost. This page's own success and home pages by default. */
+    returnUrls?: () => ReturnUrls | undefined;
+    /** Where a guest's cart is kept between page loads: the browser's `localStorage` by default. */
+    cartStorage?: KeyValuePort;
+    /** The language the store answers the cart in (names, options): read at each call. */
+    langCode?: () => string | undefined;
+    /** Whether a guest's cart is priced with `/cart/total` (default: yes). `false` for a site that prices and describes its cart with the checkout's preview: see `CartStoreOptions.pricing`. */
+    cartPricing?: boolean;
+}
+export interface Commerce {
+    storeId: string;
+    /** The customer's session: its client carries the customer's JWT. */
+    auth: Auth;
+    /** The catalog's calls, through the cache. */
+    catalog: CachedCatalog;
+    cache: Cache;
+    /** The cart: a guest's in the browser, a customer's in the store, following `auth`. */
+    cart: CartStore;
+    /** The checkout: what the customer chose, what it costs (`quote`) and the start of the payment (`pay`). Needs `checkoutApiUrl`: without it this throws where it is read. */
+    checkout: CheckoutStore;
+    /** The requests about the customer's own account: password reset, verification, deletion, two-factor, newsletter. */
+    account: Account;
+    /** The addresses: a customer's in the store, a guest's in memory, following `auth`. */
+    addresses: AddressBook;
+    /** What the customer bought: orders and subscriptions, as resources of the cache. */
+    orders: Orders;
+    /** Returns: a customer's requests and the guest's link flow. */
+    returns: Returns;
+    /** The customer's wishlist (a guest has none). */
+    wishlist: Wishlist;
+    /** What the customer writes: their reviews of what they bought. */
+    reviews: Reviews;
+}
+export declare function createCommerce(config: CommerceConfig): Commerce;
+//# sourceMappingURL=commerce.d.ts.map

package/dist/commerce.js

@@ -0,0 +1,55 @@
+import { createCache } from './cache.js';
+import { createAuth } from './auth/auth.js';
+import { createCachedCatalog } from './catalog/cached.js';
+import { createAccount } from './account/account.js';
+import { createAddressApi } from './addresses/api.js';
+import { createAddressBook } from './addresses/book.js';
+import { createAuthApi } from './auth/api.js';
+import { createCartApi } from './cart/api.js';
+import { createCustomerResources } from './customer-resources.js';
+import { createOrderApi } from './orders/api.js';
+import { createReturnApi } from './returns/api.js';
+import { createReviewApi } from './reviews/api.js';
+import { createReviews } from './reviews/reviews.js';
+import { createWishlistApi } from './wishlist/api.js';
+import { createWishlist } from './wishlist/wishlist.js';
+import { createReturns } from './returns/returns.js';
+import { createOrders } from './orders/orders.js';
+import { browserKeyValuePort, createCartStorage } from './cart/storage.js';
+import { createCartStore } from './cart/store.js';
+import { createCheckoutApi } from './checkout/api.js';
+import { browserReturnUrls } from './checkout/return-urls.js';
+import { createCheckoutStore } from './checkout/store.js';
+import { createHttpClient } from './http.js';
+export function createCommerce(config) {
+    const { commerceApiUrl, catalogApiUrl, checkoutApiUrl, returnUrls, cartStorage, langCode, cartPricing, ...rest } = config;
+    const cache = createCache();
+    const catalog = createCachedCatalog(createHttpClient({ baseUrl: catalogApiUrl, storeId: config.storeId, timeoutMs: config.timeoutMs, fetch: config.fetch }), cache);
+    const auth = createAuth({ ...rest, baseUrl: commerceApiUrl });
+    const cartKept = createCartStorage(cartStorage ?? browserKeyValuePort(), config.storeId);
+    const cart = createCartStore({ api: createCartApi(auth.http), auth: auth.store, storage: cartKept, langCode, ...(cartPricing !== undefined ? { pricing: cartPricing } : {}) });
+    // Made when it is first used: a store without the checkout's address is fine until something asks for the checkout
+    let checkout;
+    const checkoutOf = () => {
+        if (checkoutApiUrl === undefined)
+            throw new Error('@webround/commerce: this store was made without the checkout API\'s address (`checkoutApiUrl`), so it does not know where to price a cart or start a payment.');
+        return (checkout ?? (checkout = createCheckoutStore({
+            api: createCheckoutApi(auth.httpFor(checkoutApiUrl)),
+            cart,
+            trackingId: () => cartKept.trackingId(),
+            langCode,
+            returnUrls: returnUrls ?? browserReturnUrls,
+            clearCart: () => cart.clear(),
+        })));
+    };
+    const account = createAccount({ api: createAuthApi(auth.http), auth: auth.store, storage: auth.storage, language: langCode });
+    const addresses = createAddressBook({ api: createAddressApi(auth.http), auth: auth.store });
+    const identity = { baseUrl: commerceApiUrl, storeId: config.storeId };
+    const customer = createCustomerResources({ cache, identity, auth: auth.store });
+    const orders = createOrders({ api: createOrderApi(auth.http), customer });
+    const returns = createReturns({ api: createReturnApi(auth.http), customer, cache, identity });
+    const wishlist = createWishlist({ api: createWishlistApi(auth.http), auth: auth.store });
+    const reviews = createReviews({ api: createReviewApi(auth.http), customer, catalog, auth: auth.store });
+    return { storeId: config.storeId, auth, catalog, cache, cart, get checkout() { return checkoutOf(); }, account, addresses, orders, returns, wishlist, reviews };
+}
+//# sourceMappingURL=commerce.js.map

package/dist/customer-resources.d.ts

@@ -0,0 +1,18 @@
+import { type Cache } from './cache.js';
+import type { CallOptions } from './catalog/types.js';
+import type { AuthStore } from './auth/store.js';
+import { type Resource, type ResourceIdentity } from './resource.js';
+export interface CustomerResources {
+    /** A question about the logged-in customer's data, or null when nobody is. `subject` is what the call is about (an order's id). */
+    resource<T>(call: string, subject: string | undefined, params: unknown, fetch: (options: CallOptions) => Promise<T>): Resource<T> | null;
+    /** Forgets what was kept for the customer: of one call (all of it, or about one subject), or of all of them. The next question is asked again. */
+    forget(call?: string, subject?: string): void;
+    /** Stops following the auth store. */
+    dispose(): void;
+}
+export declare function createCustomerResources(options: {
+    cache: Cache;
+    identity: ResourceIdentity;
+    auth: Pick<AuthStore, 'getState' | 'subscribe'>;
+}): CustomerResources;
+//# sourceMappingURL=customer-resources.d.ts.map

package/dist/customer-resources.js

@@ -0,0 +1,40 @@
+import { cachePrefix } from './cache.js';
+import { createResourceFactory } from './resource.js';
+export function createCustomerResources(options) {
+    const { cache, identity, auth } = options;
+    const make = createResourceFactory(cache, identity);
+    // The calls that were asked: what is forgotten when the customer changes
+    const calls = new Set();
+    const customerId = () => {
+        const { status, customer } = auth.getState();
+        return status === 'signedIn' && customer ? customer.customerId : null;
+    };
+    const subjectOf = (id, subject) => (subject === undefined ? id : `${id}/${subject}`);
+    let last = customerId();
+    function forget(call, subject) {
+        const id = customerId();
+        for (const c of call === undefined ? [...calls] : [call]) {
+            // With a subject, only what was asked about it, for this customer; else everything of the call, whoever it was for
+            cache.invalidate(cachePrefix({ base: identity.baseUrl, storeId: identity.storeId, call: c, subject: subject !== undefined && id !== null ? subjectOf(id, subject) : undefined }));
+        }
+    }
+    const stop = auth.subscribe(() => {
+        const now = customerId();
+        if (now === last)
+            return;
+        last = now;
+        forget();
+    });
+    return {
+        resource(call, subject, params, fetch) {
+            const id = customerId();
+            if (id === null)
+                return null;
+            calls.add(call);
+            return make(call, subjectOf(id, subject), params, fetch);
+        },
+        forget,
+        dispose: stop,
+    };
+}
+//# sourceMappingURL=customer-resources.js.map