@wocart/storefront 1.19.0 → 1.21.0

package/dist/answer-readers.d.ts

@@ -1,15 +1,22 @@
 /**
  * Readers for what this package's server parts hand the browser: the delivery
- * rates a page carries and the coupon outcome of a cart quote.
+ * rates a page carries, a cart quote, and the coupon outcome in it.
  *
- * The server built both with `ShippingRatesSchema` / `CouponOutcomeSchema`, so
- * the browser need not run those schemas. A page can still be cached apart
+ * The server built them with `ShippingRatesSchema`, `CartValidationSchema` and
+ * `CouponOutcomeSchema`, so the browser need not run those schemas. A page can still be cached apart
  * from its scripts, so a value of another version's shape is possible; these
  * accept exactly what the schemas accept and return what they would — extra
  * keys left out — without bringing Zod into a shopper's page. A property test
  * holds each reader to its schema.
  */
-import type { CouponOutcome, ShippingRates } from "./types.js";
+import type { CartValidation, CouponOutcome, ShippingRates } from "./types.js";
+/**
+ * A cart quote (`CartValidation`) — the `data` of the theme's cart-validate
+ * route — or null when the value is not one. What the quote says is the
+ * server's: lines re-priced from the catalog, rewards, the subtotal, the free
+ * delivery progress, and, when asked, the delivery fee and the coupon's outcome.
+ */
+export declare function readCartQuote(value: unknown): CartValidation | null;
 /** The delivery rates of a value (`ShippingRates`), or null when it is not a rate table. */
 export declare function readShippingRates(value: unknown): ShippingRates | null;
 /** What a coupon did in a quote (`CouponOutcome`), or null when the value is not one. */

package/dist/answer-readers.js

@@ -1,5 +1,119 @@
 const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const isInteger = (value) => typeof value === "number" && Number.isSafeInteger(value);
+const isNullableString = (value) => value === null || typeof value === "string";
+/** An optional field the schema reads as `.nullish()`: absent stays absent, null and the type are kept, anything else refuses. */
+function nullish(source, key, accepts) {
+    if (!(key in source) || source[key] === undefined)
+        return { ok: true, entry: {} };
+    const value = source[key];
+    return value === null || accepts(value) ? { ok: true, entry: { [key]: value } } : { ok: false, entry: {} };
+}
+const isString = (value) => typeof value === "string";
+const BLOCKERS = ["missing", "unlisted", "out_of_stock"];
+function readQuoteLine(value) {
+    if (!isObject(value))
+        return null;
+    const { productId, variantId, variantLabel, productName, quantity, unitPrice, lineTotal, maxQuantity, blocker } = value;
+    if (typeof productId !== "string" || !isNullableString(variantId) || !isNullableString(variantLabel) || typeof productName !== "string")
+        return null;
+    if (!isInteger(quantity) || !isFiniteNumber(unitPrice) || !isFiniteNumber(lineTotal))
+        return null;
+    if (maxQuantity !== null && !isFiniteNumber(maxQuantity))
+        return null;
+    if (blocker !== null && !(typeof blocker === "string" && BLOCKERS.includes(blocker)))
+        return null;
+    const offerId = nullish(value, "offerId", isString);
+    const offerName = nullish(value, "offerName", isString);
+    const discount = nullish(value, "discount", isFiniteNumber);
+    if (!offerId.ok || !offerName.ok || !discount.ok)
+        return null;
+    return {
+        productId,
+        variantId,
+        variantLabel,
+        productName,
+        quantity,
+        unitPrice,
+        lineTotal,
+        ...offerId.entry,
+        ...offerName.entry,
+        ...discount.entry,
+        maxQuantity,
+        blocker: blocker,
+    };
+}
+function readReward(value) {
+    if (!isObject(value))
+        return null;
+    const { offerId, productId, productName, quantity } = value;
+    if (typeof offerId !== "string" || !isNullableString(productId) || !isNullableString(productName) || !isInteger(quantity))
+        return null;
+    const offerName = nullish(value, "offerName", isString);
+    const variantId = nullish(value, "variantId", isString);
+    const variantLabel = nullish(value, "variantLabel", isString);
+    if (!offerName.ok || !variantId.ok || !variantLabel.ok)
+        return null;
+    return { offerId, ...offerName.entry, productId, productName, ...variantId.entry, ...variantLabel.entry, quantity };
+}
+function readDelivery(value) {
+    if (!isObject(value))
+        return null;
+    if (value.available === true)
+        return isFiniteNumber(value.fee) && isFiniteNumber(value.total) ? { available: true, fee: value.fee, total: value.total } : null;
+    return value.available === false && value.fee === null && value.total === null ? { available: false, fee: null, total: null } : null;
+}
+function readList(value, read) {
+    if (!Array.isArray(value))
+        return null;
+    const items = [];
+    for (const item of value) {
+        const parsed = read(item);
+        if (parsed === null)
+            return null;
+        items.push(parsed);
+    }
+    return items;
+}
+/**
+ * A cart quote (`CartValidation`) — the `data` of the theme's cart-validate
+ * route — or null when the value is not one. What the quote says is the
+ * server's: lines re-priced from the catalog, rewards, the subtotal, the free
+ * delivery progress, and, when asked, the delivery fee and the coupon's outcome.
+ */
+export function readCartQuote(value) {
+    if (!isObject(value) || !isFiniteNumber(value.subtotal))
+        return null;
+    const lines = readList(value.lines, readQuoteLine);
+    const rewards = readList(value.rewards, readReward);
+    if (lines === null || rewards === null)
+        return null;
+    const free = value.freeDelivery;
+    if (!isObject(free) || typeof free.fromOffer !== "boolean" || typeof free.qualified !== "boolean" || !isFiniteNumber(free.remaining))
+        return null;
+    if (free.threshold !== null && !isFiniteNumber(free.threshold))
+        return null;
+    let delivery = null;
+    if ("delivery" in value && value.delivery !== undefined) {
+        delivery = readDelivery(value.delivery);
+        if (delivery === null)
+            return null;
+    }
+    let coupon;
+    if ("coupon" in value && value.coupon !== undefined) {
+        coupon = value.coupon === null ? null : readCouponOutcome(value.coupon);
+        if (coupon === null && value.coupon !== null)
+            return null;
+    }
+    return {
+        lines,
+        subtotal: value.subtotal,
+        rewards,
+        freeDelivery: { fromOffer: free.fromOffer, threshold: free.threshold, qualified: free.qualified, remaining: free.remaining },
+        ...(delivery === null ? {} : { delivery }),
+        ...(coupon === undefined ? {} : { coupon }),
+    };
+}
 /** The delivery rates of a value (`ShippingRates`), or null when it is not a rate table. */
 export function readShippingRates(value) {
     if (!isObject(value))

package/dist/astro.d.ts

@@ -6,3 +6,7 @@ export { placeOrderInput, executePlaceOrder, collectForwardedHeaders, } from "./
 export type { PlaceOrderInput, PlaceOrderResult } from "./actions.js";
 export { runFormAction, resolveActionRedirectDecision } from "./middleware.js";
 export type { PrgDecision, ActionMiddlewareDeps, ActionDescriptor } from "./middleware.js";
+export { lookupOrder, orderLookupInput } from "./order-lookup.js";
+export type { OrderLookup, OrderLookupInput } from "./order-lookup.js";
+export { notFound, resolvePreviewStore, resolveStoreRequest } from "./store-request.js";
+export type { NotFoundContext, ResolvedStore, StoreRequestOptions, StoreRequestResolution } from "./store-request.js";

package/dist/astro.js

@@ -2,3 +2,5 @@ export { createProxyEndpoint } from "./endpoints/proxy.js";
 export { createStorefrontRoutes, REVIEWS_PAGE_DEFAULT, REVIEWS_PAGE_MAX, } from "./endpoints/storefront-routes.js";
 export { placeOrderInput, executePlaceOrder, collectForwardedHeaders, } from "./actions.js";
 export { runFormAction, resolveActionRedirectDecision } from "./middleware.js";
+export { lookupOrder, orderLookupInput } from "./order-lookup.js";
+export { notFound, resolvePreviewStore, resolveStoreRequest } from "./store-request.js";

package/dist/basket.d.ts

@@ -10,6 +10,7 @@
  * every line at checkout.
  */
 import type { BasketLine, BasketLineInput } from "./domain.js";
+import type { CreateOrderVariantSelection } from "./types.js";
 /** Default key used in browser storage, versioned to prevent schema drift crashes. */
 export declare const DEFAULT_BASKET_STORAGE_KEY = "cod_cart_v1";
 /**
@@ -35,10 +36,12 @@ export interface BasketStoreOptions {
     maxLineQuantity?: number;
 }
 export type BasketListener = (lines: readonly BasketLine[]) => void;
+/** A product line before its variant and quantity: what `addSelections` gives each variant chosen. */
+export type BasketSelectionLine = Omit<BasketLine, "variantId" | "variantLabel" | "quantity">;
 /**
  * Basket Store Interface.
  *
- * Deep module interface: 9 simple, focused methods that hide all storage
+ * Deep module interface: simple, focused methods that hide all storage
  * failures, cross-tab events, line reconciliation, and normalization.
  */
 export interface BasketStore {
@@ -50,6 +53,13 @@ export interface BasketStore {
     getSubtotal(): number;
     /** Add a line. Merges with existing product+variant, caps quantities. */
     addLine(line: BasketLine): readonly BasketLine[];
+    /**
+     * Add a choice made piece by piece — an offer of three in two sizes, as an
+     * order's `variantSelections` carries it: one line per variant, its
+     * quantity the pieces of that variant, as one change. All or nothing: when
+     * the basket has no room for every new line, nothing is added.
+     */
+    addSelections(line: BasketSelectionLine, selections: readonly CreateOrderVariantSelection[]): readonly BasketLine[];
     /** Update quantity of an existing line. Removes if <= 0. */
     setQuantity(key: string, quantity: number): readonly BasketLine[];
     /** Remove a line by its composite key. */

package/dist/basket.js

@@ -227,6 +227,23 @@ export function createBasketStore(options = {}) {
             }
             return commit([...state, line]);
         },
+        addSelections(line, selections) {
+            const pieces = new Map();
+            for (const selection of selections) {
+                const existing = pieces.get(selection.variantId);
+                if (existing)
+                    existing.quantity += 1;
+                else
+                    pieces.set(selection.variantId, { ...line, variantId: selection.variantId, variantLabel: selection.variantLabel ?? null, quantity: 1 });
+            }
+            if (pieces.size === 0)
+                return state;
+            const held = new Set(state.map((l) => basketLineKey(l.productId, l.variantId)));
+            const added = [...pieces.values()].filter((piece) => !held.has(basketLineKey(piece.productId, piece.variantId))).length;
+            if (state.length + added > maxLines)
+                return state;
+            return commit([...state, ...pieces.values()]);
+        },
         setQuantity(key, quantity) {
             if (!Number.isInteger(quantity) || quantity < 1) {
                 return this.removeLine(key);

package/dist/catalog.d.ts

@@ -0,0 +1,24 @@
+/**
+ * How a storefront listing can be ordered, for a theme's sort control. Absent,
+ * a listing keeps its own order: a collection's, a search's best match first,
+ * else newest.
+ */
+export declare const PRODUCT_SORTS: readonly ["newest", "price-ascending", "price-descending"];
+/**
+ * Every step `orders.status()` can name, in a shopper's words, for a theme to
+ * word each one. A newer server may add one; a theme then shows its general
+ * words.
+ */
+export declare const SHOPPER_ORDER_STAGES: readonly ["placed", "confirmed", "preparing", "shipped", "out_for_delivery", "delivered", "returned", "cancelled"];
+/**
+ * The steps an order passes on its way to the shopper, in order — what a
+ * tracking page's progress shows. `returned` and `cancelled` end an order off
+ * this path, and a stage a newer server adds is on none of it.
+ */
+export declare const SHOPPER_ORDER_JOURNEY: readonly ["placed", "confirmed", "preparing", "shipped", "out_for_delivery", "delivered"];
+/**
+ * The collections every store starts with, the likeliest to hold products
+ * first: what to show when a page needs a collection and none was named (an
+ * editor's preview of the collection template).
+ */
+export declare const DEFAULT_COLLECTION_HANDLES: readonly ["best-sellers", "new-arrivals", "featured"];

package/dist/catalog.js

@@ -0,0 +1,33 @@
+/**
+ * How a storefront listing can be ordered, for a theme's sort control. Absent,
+ * a listing keeps its own order: a collection's, a search's best match first,
+ * else newest.
+ */
+export const PRODUCT_SORTS = ["newest", "price-ascending", "price-descending"];
+/**
+ * Every step `orders.status()` can name, in a shopper's words, for a theme to
+ * word each one. A newer server may add one; a theme then shows its general
+ * words.
+ */
+export const SHOPPER_ORDER_STAGES = [
+    "placed",
+    "confirmed",
+    "preparing",
+    "shipped",
+    "out_for_delivery",
+    "delivered",
+    "returned",
+    "cancelled",
+];
+/**
+ * The steps an order passes on its way to the shopper, in order — what a
+ * tracking page's progress shows. `returned` and `cancelled` end an order off
+ * this path, and a stage a newer server adds is on none of it.
+ */
+export const SHOPPER_ORDER_JOURNEY = ["placed", "confirmed", "preparing", "shipped", "out_for_delivery", "delivered"];
+/**
+ * The collections every store starts with, the likeliest to hold products
+ * first: what to show when a page needs a collection and none was named (an
+ * editor's preview of the collection template).
+ */
+export const DEFAULT_COLLECTION_HANDLES = ["best-sellers", "new-arrivals", "featured"];

package/dist/client/orders.d.ts

@@ -13,7 +13,7 @@
  */
 import { type ClientCore, type ClientResult } from "./core.js";
 import type { AbandonedCheckoutInput } from "../domain.js";
-import type { CreateOrderInput, CreatedOrder, OrderTracking, OtpSendResult, OtpVerifyResult } from "../types.js";
+import type { CreateOrderInput, CreatedOrder, OrderTracking, OtpSendResult, OtpVerifyResult, ShopperOrderProof, ShopperOrderStatus } from "../types.js";
 export interface AbandonedNamespace {
     /**
      * Upsert an abandoned-checkout record — fire-and-forget. `forwardedHeaders`
@@ -62,6 +62,15 @@ export interface OrdersNamespace {
      * the thank-you page fires no conversion at all in that case.
      */
     tracking(orderId: string): Promise<OrderTracking | null>;
+    /**
+     * Where a shopper's order is, proved by its number and the phone it was
+     * placed with: its step in the shopper's words, its lines and total, and
+     * the carrier's tracking number once shipped. A wrong number and a wrong
+     * phone both fail with `ORDER_NOT_FOUND`; too many tries with
+     * `ORDER_LOOKUP_RATE_LIMITED` and `windowSeconds`. `forwardedHeaders`
+     * carries the shopper's address: the limit counts per shopper.
+     */
+    status(proof: ShopperOrderProof, forwardedHeaders?: Record<string, string>): Promise<ClientResult<ShopperOrderStatus>>;
     abandoned: AbandonedNamespace;
     otp: OtpNamespace;
 }

package/dist/client/orders.js

@@ -11,7 +11,7 @@
  * - tracking resolves to null on any failure — firing no conversion event
  *   is recoverable; reporting it to the wrong ad account is not.
  */
-import { CreatedOrderSchema, IdResponseSchema, OrderTrackingSchema, OtpSendResultSchema, OtpVerifyResultSchema, } from "../schemas.js";
+import { CreatedOrderSchema, IdResponseSchema, OrderTrackingSchema, OtpSendResultSchema, ShopperOrderStatusSchema, OtpVerifyResultSchema, } from "../schemas.js";
 import { STOREFRONT_OPERATIONS } from "../operations.js";
 import { isNotFoundAnswer, reportDegradedRead } from "./core.js";
 /**
@@ -39,6 +39,13 @@ export function createOrdersNamespace(core) {
                 return null;
             }
         },
+        async status(proof, forwardedHeaders) {
+            return core.post("/store/orders/status", { orderNumber: proof.orderNumber, phone: proof.phone }, {
+                ...(forwardedHeaders ? { headers: forwardedHeaders } : {}),
+                schema: ShopperOrderStatusSchema,
+                operation: STOREFRONT_OPERATIONS.ordersStatus,
+            });
+        },
         abandoned: {
             async upsert(body, forwardedHeaders) {
                 // The server answers `{ success, id }` — the payload sits at the

package/dist/client/products.d.ts

@@ -31,11 +31,21 @@ export interface ProductsNamespace {
      */
     list(filters?: ProductListFilters): Promise<ProductList[]>;
     /**
-     * One page of products, and whether another page follows. The server is
-     * asked for one row more than the page, so the answer is exact without a
-     * count query. A failed read is an empty final page, as `list` degrades.
+     * One page of products, whether another page follows, and how many the
+     * whole listing holds. The server is asked for one row more than the page,
+     * so `hasNext` is exact even from a server that does not count. A failed
+     * read is an empty final page, as `list` degrades.
      */
     page(filters?: ProductListFilters): Promise<ProductPage>;
+    /**
+     * The products a shopper's words find — every word in the product's name,
+     * in the client's language or the catalog's, or in its tags — as a page,
+     * with the listing filters, sort and paging. Without a `sort`, products
+     * whose name holds every word come first. Blank words find nothing; a
+     * server that predates search answers an empty page (reported through
+     * `onError`), never the whole catalog.
+     */
+    search(text: string, filters?: ProductListFilters): Promise<ProductPage>;
     /**
      * Reviews sub-namespace
      */

package/dist/client/products.js

@@ -12,7 +12,7 @@
  * half-shaped product into a theme.
  */
 import { z } from "zod";
-import { ProductListSchema, ProductSchema, ReviewEligibilitySchema, ReviewListEnvelopeSchema, ReviewSubmitResultSchema, ReviewUploadSchema } from "../schemas.js";
+import { ProductListSchema, ProductPageEnvelopeSchema, ProductSchema, ReviewEligibilitySchema, ReviewListEnvelopeSchema, ReviewSubmitResultSchema, ReviewUploadSchema } from "../schemas.js";
 import { STOREFRONT_OPERATIONS } from "../operations.js";
 import { localizedPath } from "./paths.js";
 import { isNotFoundAnswer, reportDegradedRead } from "./core.js";
@@ -24,16 +24,19 @@ export const PRODUCT_PAGE_MAX = 99;
  * Create products namespace
  */
 export function createProductsNamespace(core) {
+    const query = (filters, extra = {}) => ({
+        ...extra,
+        categoryId: filters?.categoryId || undefined,
+        collection: filters?.collection || undefined,
+        onSale: filters?.onSale ? "true" : undefined,
+        featured: filters?.featured ? "true" : undefined,
+        sort: filters?.sort || undefined,
+        limit: filters?.limit === undefined ? undefined : String(filters.limit),
+        offset: filters?.offset ? String(filters.offset) : undefined,
+    });
     const list = async (filters) => {
         try {
-            const products = await core.get(localizedPath(core.config, "/store/products", {
-                categoryId: filters?.categoryId || undefined,
-                collection: filters?.collection || undefined,
-                onSale: filters?.onSale ? "true" : undefined,
-                featured: filters?.featured ? "true" : undefined,
-                limit: filters?.limit === undefined ? undefined : String(filters.limit),
-                offset: filters?.offset ? String(filters.offset) : undefined,
-            }), z.array(ProductListSchema), { operation: STOREFRONT_OPERATIONS.productsList });
+            const products = await core.get(localizedPath(core.config, "/store/products", query(filters)), z.array(ProductListSchema), { operation: STOREFRONT_OPERATIONS.productsList });
             return products ?? [];
         }
         catch (error) {
@@ -41,6 +44,22 @@ export function createProductsNamespace(core) {
             return [];
         }
     };
+    /** One page of `path`, asked for one row more than the page so `hasNext` is exact. */
+    const page = async (path, filters, extra, operation) => {
+        const size = Math.min(Math.max(1, filters?.limit ?? PRODUCT_PAGE_DEFAULT), PRODUCT_PAGE_MAX);
+        try {
+            const envelope = await core.get(localizedPath(core.config, path, query({ ...filters, limit: size + 1 }, extra)), ProductPageEnvelopeSchema, {
+                envelope: true,
+                operation,
+            });
+            const rows = envelope?.data ?? [];
+            return { items: rows.slice(0, size), hasNext: rows.length > size, total: envelope?.total ?? null };
+        }
+        catch (error) {
+            reportDegradedRead(core.config, error, operation);
+            return { items: [], hasNext: false, total: null };
+        }
+    };
     return {
         async get(handle) {
             try {
@@ -55,9 +74,13 @@ export function createProductsNamespace(core) {
         },
         list,
         async page(filters) {
-            const size = Math.min(Math.max(1, filters?.limit ?? PRODUCT_PAGE_DEFAULT), PRODUCT_PAGE_MAX);
-            const rows = await list({ ...filters, limit: size + 1 });
-            return { items: rows.slice(0, size), hasNext: rows.length > size };
+            return page("/store/products", filters, {}, STOREFRONT_OPERATIONS.productsList);
+        },
+        async search(text, filters) {
+            const q = text.trim().slice(0, 100);
+            if (q === "")
+                return { items: [], hasNext: false, total: 0 };
+            return page("/store/search", filters, { q }, STOREFRONT_OPERATIONS.productsSearch);
         },
         reviews: {
             async list(productId, pagination) {

package/dist/coupon.d.ts

@@ -7,7 +7,7 @@
  * code does not apply. A theme shows those answers; it never decides one.
  */
 import type { ClientResult } from "./domain.js";
-import type { CouponRefusal } from "./types.js";
+import type { CouponRefusal, CouponRefusalReason } from "./types.js";
 /** The error code of an order refused for its code. */
 export declare const COUPON_NOT_APPLICABLE = "COUPON_NOT_APPLICABLE";
 /** The query parameter a shareable coupon link carries: `/products/robe?coupon=RAMADAN10`. */
@@ -16,3 +16,18 @@ export declare const COUPON_URL_PARAM = "coupon";
 export declare function couponFromUrl(url: URL): string | null;
 /** Why an order was refused for its code, or null when it was refused — or placed — for anything else. */
 export declare function couponRefusalOf(result: ClientResult<unknown>): CouponRefusal | null;
+/** Every reason a code is refused for, as the platform names them. A newer server may add one; it then reads as `refused`. */
+export declare const COUPON_REFUSAL_REASONS: readonly ["not_found", "not_started", "expired", "used_up", "identify_first", "not_eligible", "already_used", "no_eligible_products", "offer_applied", "below_minimum_subtotal", "below_minimum_quantity", "delivery_already_free"];
+/**
+ * The reasons about the basket, not the code: the code is good, but this
+ * basket does not meet it yet — a phone still to type, a product under an
+ * offer, a minimum not reached, delivery already free.
+ */
+export declare const COUPON_HINT_REASONS: readonly CouponRefusalReason[];
+/**
+ * How a refusal reads: `hint` when the shopper can still meet the code with
+ * this basket (see `COUPON_HINT_REASONS`), `refused` when the code itself
+ * cannot be used — unknown, outside its dates, used up, not for this shopper —
+ * and for a reason this release does not know.
+ */
+export declare function couponRefusalTone(reason: CouponRefusalReason): "refused" | "hint";

package/dist/coupon.js

@@ -17,3 +17,40 @@ export function couponRefusalOf(result) {
         ...(typeof result.startsAt === "string" ? { startsAt: result.startsAt } : {}),
     };
 }
+/** Every reason a code is refused for, as the platform names them. A newer server may add one; it then reads as `refused`. */
+export const COUPON_REFUSAL_REASONS = [
+    "not_found",
+    "not_started",
+    "expired",
+    "used_up",
+    "identify_first",
+    "not_eligible",
+    "already_used",
+    "no_eligible_products",
+    "offer_applied",
+    "below_minimum_subtotal",
+    "below_minimum_quantity",
+    "delivery_already_free",
+];
+/**
+ * The reasons about the basket, not the code: the code is good, but this
+ * basket does not meet it yet — a phone still to type, a product under an
+ * offer, a minimum not reached, delivery already free.
+ */
+export const COUPON_HINT_REASONS = [
+    "identify_first",
+    "no_eligible_products",
+    "offer_applied",
+    "below_minimum_subtotal",
+    "below_minimum_quantity",
+    "delivery_already_free",
+];
+/**
+ * How a refusal reads: `hint` when the shopper can still meet the code with
+ * this basket (see `COUPON_HINT_REASONS`), `refused` when the code itself
+ * cannot be used — unknown, outside its dates, used up, not for this shopper —
+ * and for a reason this release does not know.
+ */
+export function couponRefusalTone(reason) {
+    return COUPON_HINT_REASONS.includes(reason) ? "hint" : "refused";
+}

package/dist/endpoints/storefront-routes.d.ts

@@ -3,8 +3,8 @@
  *
  * Every theme needs the same routes between the shopper's browser and the
  * platform: OTP send and verify, cart validation, abandoned-checkout tracking
- * and its conversion, communes, and reviews (list, find the order, send a
- * photo or voice note, submit). What
+ * and its conversion, communes, reviews (list, find the order, send a photo
+ * or voice note, submit), and where a shopper's order is. What
  * each one must get right is decided here once — the cross-origin check on
  * every POST, the shopper's address forwarded wherever the server counts or
  * attributes per shopper, the input bounds, and the response shape the
@@ -59,6 +59,12 @@ export interface StorefrontRoutes<C extends AstroAPIContext> {
     readonly reviewUpload: StorefrontApiRoute<C>;
     /** POST a `ReviewInput` → 201 `{ success: true, data: { id, visibility } }`. */
     readonly reviewSubmit: StorefrontApiRoute<C>;
+    /**
+     * POST `{ orderNumber, phone }` → `{ data: ShopperOrderStatus }`. A wrong
+     * number or phone is refused with `ORDER_NOT_FOUND`; too many tries with
+     * `ORDER_LOOKUP_RATE_LIMITED` (429, `windowSeconds`).
+     */
+    readonly orderStatus: StorefrontApiRoute<C>;
 }
 export declare const REVIEWS_PAGE_DEFAULT = 20;
 export declare const REVIEWS_PAGE_MAX = 50;

package/dist/endpoints/storefront-routes.js

@@ -3,8 +3,8 @@
  *
  * Every theme needs the same routes between the shopper's browser and the
  * platform: OTP send and verify, cart validation, abandoned-checkout tracking
- * and its conversion, communes, and reviews (list, find the order, send a
- * photo or voice note, submit). What
+ * and its conversion, communes, reviews (list, find the order, send a photo
+ * or voice note, submit), and where a shopper's order is. What
  * each one must get right is decided here once — the cross-origin check on
  * every POST, the shopper's address forwarded wherever the server counts or
  * attributes per shopper, the input bounds, and the response shape the
@@ -24,6 +24,7 @@
 import { z } from "zod";
 import { AbandonedCheckoutInputSchema, BasketLineInputSchema, DeliveryDestinationSchema, ProductQuoteInputSchema, WilayaIdSchema, } from "../domain.js";
 import { MAX_BASKET_LINES } from "../basket-line.js";
+import { orderLookupInput } from "../order-lookup.js";
 import { createProxyEndpoint, } from "./proxy.js";
 export const REVIEWS_PAGE_DEFAULT = 20;
 export const REVIEWS_PAGE_MAX = 50;
@@ -191,5 +192,11 @@ export function createStorefrontRoutes(options) {
             successBody: (data) => ({ success: true, data }),
             call: (client, review) => client.products.reviews.submit(defined(review)),
         }),
+        orderStatus: route({
+            method: "POST",
+            inputSchema: orderLookupInput,
+            forwardAttribution: true,
+            call: (client, proof, headers) => client.orders.status(proof, headers),
+        }),
     };
 }

package/dist/index.d.ts

@@ -11,8 +11,8 @@
  */
 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, mediaImageUrl, mediaUrl, } from "./utils/image.js";
-export type { ImageHelpers, ImageResizeOptions, MediaImageParams } from "./utils/image.js";
+export { optimizeImage, generateSrcSet, IMAGE_SIZES, getCardImage, getGalleryImage, getThumbnailImage, getHeroImage, getCategoryImage, getLogoImage, createImageHelpers, mediaImageUrl, mediaImageSrcset, mediaUrl, pictureOf, } from "./utils/image.js";
+export type { ImageHelpers, ImageResizeOptions, MediaImageParams, MediaImageSrcsetOptions, PickedImage, Picture } 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";
@@ -24,13 +24,21 @@ export type { LocalePath, LocaleRouting } from "./locale-routing.js";
 export type { StorefrontPageMatch, StorefrontPageType, StorefrontPathParams, StorefrontRoute } from "./routes.js";
 export { createBasketStore, createMemoryStorageAdapter, createLocalStorageAdapter, DEFAULT_BASKET_STORAGE_KEY, toOrderItems, } from "./basket.js";
 export { MAX_BASKET_LINES, MAX_BASKET_LINE_QUANTITY, basketLineKey } from "./basket-line.js";
-export type { BasketStore, BasketStorageAdapter, BasketStoreOptions, BasketListener, } from "./basket.js";
+export type { BasketStore, BasketStorageAdapter, BasketStoreOptions, BasketListener, BasketSelectionLine, } 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 { isWilayaId } from "./wilaya-id.js";
-export { readCouponOutcome, readShippingRates } from "./answer-readers.js";
+export { readCartQuote, readCouponOutcome, readShippingRates } from "./answer-readers.js";
+export { createQuoter } from "./quote.js";
+export type { Quoter, QuoterOptions, QuoteResult } from "./quote.js";
+export { isOrderNumber, ORDER_NUMBER_PATTERN } from "./order-number.js";
+export { DEFAULT_COLLECTION_HANDLES, PRODUCT_SORTS, SHOPPER_ORDER_JOURNEY, SHOPPER_ORDER_STAGES } from "./catalog.js";
+export { SEO_TEXT_LIMITS, jsonLd, productMeta, productStructuredData } from "./seo.js";
+export type { PageMeta, ProductStructuredDataOptions } from "./seo.js";
+export { REVIEW_REFUSAL_CODES, REVIEW_TEXT_LIMITS } from "./reviews.js";
+export type { ReviewRefusalCode } from "./reviews.js";
 export type { CommuneTuple } from "./data/communes.js";
 export { normalizeAlgerianPhone, toLocalAlgerianMobile } from "./phone.js";
 export * from "./types.js";
@@ -39,12 +47,12 @@ export * from "./domain.js";
 export * from "./operations.js";
 export * from "./product-view.js";
 export { getOfferTierView, getQuantityTierViews } from "./offer-view.js";
-export { COUPON_NOT_APPLICABLE, COUPON_URL_PARAM, couponFromUrl, couponRefusalOf } from "./coupon.js";
+export { COUPON_HINT_REASONS, COUPON_NOT_APPLICABLE, COUPON_REFUSAL_REASONS, COUPON_URL_PARAM, couponFromUrl, couponRefusalOf, couponRefusalTone, } from "./coupon.js";
 export { initialVariant, optionStates, pickOption, variantFor } from "./variant-picker.js";
 export type { OptionSelection, OptionState, PickerVariant } from "./variant-picker.js";
 export type { CartQuoteOptions } from "./client/cart.js";
 export type { OfferTierInput, OfferTierView, QuantityTierView } from "./offer-view.js";
-export { createAbandonedCheckoutTracker } from "./abandoned-checkout.js";
-export type { AbandonedCheckoutPorts, AbandonedCheckoutSnapshot, AbandonedCheckoutStorage, AbandonedCheckoutTracker, } from "./abandoned-checkout.js";
+export { ABANDONED_CHECKOUT_SESSION_KEY, convertAbandonedCheckout, createAbandonedCheckoutTracker, createBrowserAbandonedCheckoutTracker, } from "./abandoned-checkout.js";
+export type { AbandonedCheckoutConversion, AbandonedCheckoutHost, AbandonedCheckoutPorts, AbandonedCheckoutSnapshot, AbandonedCheckoutStorage, AbandonedCheckoutTracker, BrowserAbandonedCheckoutOptions, } 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";