@wocart/storefront 1.9.0 → 1.10.0

package/CHANGELOG.md

@@ -5,6 +5,18 @@ follows [semantic versioning](https://semver.org/): breaking changes ship only
 in a new major version, and an export is marked `@deprecated` for at least one
 minor release before a major removes it.
 
+## 1.10.0 — 2026-10-17
+
+### Added
+
+- **Quantity pricing.** `ProductDetail.quantityPricing` (`QuantityPricing`,
+  `QuantityPricingSchema`): a product's price tiers by quantity, each with an
+  optional free delivery — null or absent when it has none.
+  `getQuantityTierViews(pricing, unitPrice)` projects them for tiles (price,
+  per-unit price, saving); the total is the server's cart quote.
+- `CartValidationLine.offerId`: the quantity-pricing offer that priced the
+  line, whose `lineTotal` is then the tier's price. Optional.
+
 ## 1.9.0 — 2026-10-17
 
 ### Added

package/USAGE.md

@@ -223,6 +223,7 @@ server directly.
 | `productImageSource` | Which photo represents a product (cover → gallery fallback) |
 | `getProductView`, `getProductListView` | Pure price, discount, default-variant, and stock values for detail and list projections |
 | `getOfferTierView` | Pure offer-tier price, compare-price, savings, and free-shipping projection; display-only, never order authority |
+| `getQuantityTierViews` | A product's quantity-pricing tiers as tiles show them — price, per-unit price, saving against the unit price, free delivery; display-only, the total is the server's cart quote |
 | `META_CURRENCY`, `buildMetaProductPayload`, `buildMetaViewContentPayload`, `buildMetaAddToCartPayload`, `buildMetaInitiateCheckoutPayload` | Browser-safe Meta event payloads with the platform currency and catalog shape |
 | `createMetaPixelTracker` | Injected browser-pixel dispatch; the theme supplies the vendor global and keeps bootstrap/timing |
 | `createBasketStore`, `createLocalStorageAdapter`, `createMemoryStorageAdapter`, `DEFAULT_BASKET_STORAGE_KEY` | The browser basket, its storage, and the key it persists under (`cod_cart_v1`) |
@@ -625,8 +626,26 @@ if (!product) {
 ~~~
 
 Product detail includes the product fields, parsed variant options and tags,
-the category, variants, images, review statistics, and offers. The server
-decides whether a product is publicly available.
+the category, variants, images, review statistics, quantity pricing, and
+offers. The server decides whether a product is publicly available.
+
+**Quantity pricing** (`product.quantityPricing`, null when the product has
+none) prices a product by how many are bought — "1 for 2,000 DA, 2 for 3,500
+DA, 3 for 4,500 DA". The highest tier the quantity reaches prices every unit
+at its per-unit price, and a tier may include free delivery for a basket of
+that product alone. A product has at most one offer per order, so it has
+either quantity pricing or offers in `offers`, never both at once.
+
+~~~ts
+const tiles = product.quantityPricing ? getQuantityTierViews(product.quantityPricing, product.price) : [];
+// tiles: [{ quantity, price, perUnit, savingsAmount, savePct, freeShipping }]
+~~~
+
+Show the tiers as choices; never compute the total yourself. The cart quote
+(`POST /api/cart/validate`) answers what the shopper pays — each line's
+`lineTotal` already priced by its tier (`offerId` names the offer), and the
+delivery — and the order charges exactly that. A tier locked to one variant
+(`triggerVariantId`) counts and prices only that variant.
 
 ### Product lists
 

package/dist/index.d.ts

@@ -34,8 +34,8 @@ export * from "./types.js";
 export * from "./schemas.js";
 export * from "./domain.js";
 export * from "./product-view.js";
-export { getOfferTierView } from "./offer-view.js";
-export type { OfferTierInput, OfferTierView } from "./offer-view.js";
+export { getOfferTierView, getQuantityTierViews } from "./offer-view.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 { META_CURRENCY, buildMetaAddToCartPayload, buildMetaInitiateCheckoutPayload, buildMetaProductPayload, buildMetaViewContentPayload, createMetaPixelTracker, } from "./meta-tracking.js";

package/dist/index.js

@@ -25,6 +25,6 @@ export * from "./types.js";
 export * from "./schemas.js";
 export * from "./domain.js";
 export * from "./product-view.js";
-export { getOfferTierView } from "./offer-view.js";
+export { getOfferTierView, getQuantityTierViews } from "./offer-view.js";
 export { createAbandonedCheckoutTracker } from "./abandoned-checkout.js";
 export { META_CURRENCY, buildMetaAddToCartPayload, buildMetaInitiateCheckoutPayload, buildMetaProductPayload, buildMetaViewContentPayload, createMetaPixelTracker, } from "./meta-tracking.js";

package/dist/offer-view.d.ts

@@ -1,4 +1,4 @@
-import type { Offer } from "./types.js";
+import type { Offer, QuantityPricing } from "./types.js";
 export interface OfferTierView {
     isFreeShipping: boolean;
     savePct: number;
@@ -8,3 +8,20 @@ export interface OfferTierView {
 }
 export type OfferTierInput = Pick<Offer, "discountType" | "triggerQuantity" | "rewardQuantity" | "rewardUnitPrice">;
 export declare function getOfferTierView(offer: OfferTierInput, basePrice: number, comparePrice: number | null): OfferTierView;
+export interface QuantityTierView {
+    quantity: number;
+    /** What that many units cost. */
+    price: number;
+    /** What one unit costs within the tier, rounded to the dinar. */
+    perUnit: number;
+    /** What the tier saves against buying that many at `unitPrice`; 0 when it saves nothing. */
+    savingsAmount: number;
+    savePct: number;
+    freeShipping: boolean;
+}
+/**
+ * The tiers of a product's quantity pricing as tiles show them: price, per-unit
+ * price and saving against the product's unit price. Presentation only — the
+ * total for a quantity is the server's cart quote.
+ */
+export declare function getQuantityTierViews(pricing: Pick<QuantityPricing, "tiers">, unitPrice: number): QuantityTierView[];

package/dist/offer-view.js

@@ -15,3 +15,24 @@ export function getOfferTierView(offer, basePrice, comparePrice) {
         comparePrice: comparePrice === null ? null : comparePrice * offer.triggerQuantity,
     };
 }
+/**
+ * The tiers of a product's quantity pricing as tiles show them: price, per-unit
+ * price and saving against the product's unit price. Presentation only — the
+ * total for a quantity is the server's cart quote.
+ */
+export function getQuantityTierViews(pricing, unitPrice) {
+    return [...pricing.tiers]
+        .sort((a, b) => a.quantity - b.quantity)
+        .map((tier) => {
+        const listValue = unitPrice * tier.quantity;
+        const savingsAmount = Math.max(0, listValue - tier.price);
+        return {
+            quantity: tier.quantity,
+            price: tier.price,
+            perUnit: Math.round(tier.price / tier.quantity),
+            savingsAmount,
+            savePct: listValue > 0 ? Math.round((savingsAmount / listValue) * 100) : 0,
+            freeShipping: tier.freeShipping,
+        };
+    });
+}

package/dist/schemas.d.ts

@@ -43,6 +43,21 @@ export declare const OfferSchema: z.ZodObject<{
     rewardVariantLabel: z.ZodNullable<z.ZodString>;
     rewardUnitPrice: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
+/**
+ * Quantity pricing — price tiers by quantity ("2 for 3,500 DA"). The highest
+ * tier the quantity reaches prices every unit at its per-unit price; the
+ * server's cart quote is the total.
+ */
+export declare const QuantityPricingSchema: z.ZodObject<{
+    offerId: z.ZodString;
+    name: z.ZodString;
+    triggerVariantId: z.ZodNullable<z.ZodString>;
+    tiers: z.ZodArray<z.ZodObject<{
+        quantity: z.ZodNumber;
+        price: z.ZodNumber;
+        freeShipping: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const CategorySchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -201,6 +216,16 @@ export declare const ProductSchema: z.ZodObject<{
         avgRating: z.ZodNumber;
         reviewCount: z.ZodNumber;
     }, z.core.$strip>>;
+    quantityPricing: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        offerId: z.ZodString;
+        name: z.ZodString;
+        triggerVariantId: z.ZodNullable<z.ZodString>;
+        tiers: z.ZodArray<z.ZodObject<{
+            quantity: z.ZodNumber;
+            price: z.ZodNumber;
+            freeShipping: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     offers: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
@@ -629,6 +654,16 @@ export declare const LandingPageSchema: z.ZodObject<{
             avgRating: z.ZodNumber;
             reviewCount: z.ZodNumber;
         }, z.core.$strip>>;
+        quantityPricing: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            offerId: z.ZodString;
+            name: z.ZodString;
+            triggerVariantId: z.ZodNullable<z.ZodString>;
+            tiers: z.ZodArray<z.ZodObject<{
+                quantity: z.ZodNumber;
+                price: z.ZodNumber;
+                freeShipping: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
         offers: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             name: z.ZodString;
@@ -677,6 +712,7 @@ export declare const CartValidationLineSchema: z.ZodObject<{
     quantity: z.ZodNumber;
     unitPrice: z.ZodNumber;
     lineTotal: z.ZodNumber;
+    offerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     maxQuantity: z.ZodNullable<z.ZodNumber>;
     blocker: z.ZodNullable<z.ZodEnum<{
         missing: "missing";
@@ -699,6 +735,7 @@ export declare const CartValidationSchema: z.ZodObject<{
         quantity: z.ZodNumber;
         unitPrice: z.ZodNumber;
         lineTotal: z.ZodNumber;
+        offerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         maxQuantity: z.ZodNullable<z.ZodNumber>;
         blocker: z.ZodNullable<z.ZodEnum<{
             missing: "missing";

package/dist/schemas.js

@@ -42,6 +42,21 @@ export const OfferSchema = z.object({
     // it omits the field, and the product's own price stands in for the gift.
     rewardUnitPrice: z.number().nullish(),
 });
+/**
+ * Quantity pricing — price tiers by quantity ("2 for 3,500 DA"). The highest
+ * tier the quantity reaches prices every unit at its per-unit price; the
+ * server's cart quote is the total.
+ */
+export const QuantityPricingSchema = z.object({
+    offerId: z.string(),
+    name: z.string(),
+    triggerVariantId: z.string().nullable(),
+    tiers: z.array(z.object({
+        quantity: z.number().int(),
+        price: z.number().int(),
+        freeShipping: z.boolean(),
+    })),
+});
 const productCategorySchema = z.object({
     id: z.string(),
     name: z.string(),
@@ -122,6 +137,11 @@ export const ProductSchema = z.object({
     variants: z.array(ProductVariantSchema),
     images: z.array(ProductImageSchema),
     reviewStats: reviewStatsSchema.nullable(),
+    /**
+     * The product's live quantity pricing; null or absent when it has none
+     * (absent from a server that predates it).
+     */
+    quantityPricing: QuantityPricingSchema.nullish(),
     offers: z.array(OfferSchema),
 });
 export const StorePagePublicSchema = z.object({
@@ -331,6 +351,8 @@ export const CartValidationLineSchema = z.object({
     quantity: z.number().int(),
     unitPrice: z.number(),
     lineTotal: z.number(),
+    /** The quantity-pricing offer that set `lineTotal`; absent from a server that predates offers on lines. */
+    offerId: z.string().nullish(),
     maxQuantity: z.number().nullable(),
     blocker: z.enum(["missing", "unlisted", "out_of_stock"]).nullable(),
 });

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ProductSchema, ProductListSchema, CategorySchema, ProductImageSchema, ProductVariantSchema, OfferSchema, PageDocumentPayloadSchema } from "./schemas.js";
+import { ProductSchema, ProductListSchema, CategorySchema, ProductImageSchema, ProductVariantSchema, OfferSchema, QuantityPricingSchema, PageDocumentPayloadSchema } from "./schemas.js";
 export type Product = z.infer<typeof ProductSchema>;
 export type ProductList = z.infer<typeof ProductListSchema>;
 /** Compact catalog projection used in grids, cards and search results. */
@@ -10,6 +10,9 @@ export type Category = z.infer<typeof CategorySchema>;
 export type ProductImage = z.infer<typeof ProductImageSchema>;
 export type ProductVariant = z.infer<typeof ProductVariantSchema>;
 export type Offer = z.infer<typeof OfferSchema>;
+/** A product's quantity pricing — `ProductDetail.quantityPricing`. */
+export type QuantityPricing = z.infer<typeof QuantityPricingSchema>;
+export type QuantityPricingTier = QuantityPricing["tiers"][number];
 /**
  * One store's saved composition document for one surface. Transport shape
  * only — `sections` items are `unknown`; the theme
@@ -307,7 +310,10 @@ export interface CartValidationLine {
     quantity: number;
     /** CURRENT catalog price — the cart's optimistic price is display-only. */
     unitPrice: number;
+    /** What the line costs: unit price × quantity, or its quantity-pricing tier's price. */
     lineTotal: number;
+    /** The quantity-pricing offer that set `lineTotal`; null or absent at the catalog price. */
+    offerId?: string | null | undefined;
     /** Units still available; null when the product is not stock-tracked. */
     maxQuantity: number | null;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wocart/storefront",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Typed, validated SDK for Wocart cash-on-delivery storefronts: catalog reads, basket, checkout, OTP and order tracking, with Astro adapters.",
   "keywords": [
     "wocart",