@asstio-dev/storefront 0.16.1 → 0.17.0

package/README.md

@@ -243,6 +243,56 @@ config. Holes in the data never throw: a missing image, description or price onl
 
 hreflang sets are only as reciprocal as the API's `alternateUrls`; the SDK renders what the API gives.
 
+### Product facts and GA4
+
+Cards and cart lines carry the product facts the product page has: `brand`, `categories`, `shortDescription` and
+`attributes` (minus `type: "html"` attributes, which stay on the product page). A card has them flat; a cart line under
+`line.product`, with the line's own brand on `line.variant.brand`. An order line has the same `product`/`variant`
+shape without `shortDescription` (`productFacts(orderLine).shortDescription` is `null`): its facts are the ones the
+charged checkout snapshot captured, never re-resolved — `url`, `facet` and attribute `facetKey`/`valueKeys` are `null`
+there, the blocks are empty on orders placed before they existed, and `null` on fee, shipping and adjustment lines.
+`productFacts()` reads them from any source:
+
+```ts
+const facts = productFacts(line);           // card, product, { product, variant }, cart line or product order line
+render(facts.brand?.label);                 // the item's brand: the variant's own, never a fallback to the family's
+render(facts.productBrand?.label);          // the family brand
+```
+
+`brand` is the selected or purchased variant's brand, and `null` can mean the variant deliberately has none — do not
+fall back to `productBrand`. **Categories carry no primary meaning**: `categories[0]` may be a gender, a brand or a
+product-type node. Pick the one you want by its root.
+
+`toGa4Item()` and `toGa4Ecommerce()` map the same sources to GA4 ecommerce data. They are pure: they send nothing and
+know nothing about consent or a data layer.
+
+| Source | `item_id` | `item_brand` | `price` | `quantity` | `item_variant` |
+|---|---|---|---|---|---|
+| card (impression) | the family `sku` | `brand.label` | from-price | 1 | — |
+| `{ product, variant }` | the variant `sku` | the variant's brand | the variant's price | 1 | selected options |
+| cart line | the line `sku` | the variant's brand | the line's unit price | the line's | selected options |
+| order line (product) | the line `sku` | the variant's brand | the unit price | the line's | options |
+
+- A card is a family impression; later events carry the purchased sku. Pass `itemId` to report at family level.
+- `price` and `value` are **net of VAT** by default, as GA4 defines them: 2 × 125.00 at 25 % gives `price: 100`,
+  `value: 200`. `value` is the sum of the items' rounded prices, so it need not match accounting to the öre (3 × 9.99 at
+  25 % gives `price: 7.99`, `value: 23.97`). Pass `tax: "include"` to report gross on purpose.
+- For `add_to_cart` and `remove_from_cart`, pass `quantity`: the positive number of units added or removed, never the
+  line's new total.
+- `item_category`…`item_category5` come from one category's `pathNames`: by default the longest, or the one your
+  `pickCategory` returns. A `pickCategory` that returns `undefined` means no category fields.
+- No `discount`: `compareAt` is a recommended price, not a discount applied.
+- A source without a price throws `AnalyticsError`, as does a non-product order line; never `price: 0`.
+- For an order, `transaction_id` is `order.id` (stable from completion; `orderNumber` is null until export), `tax` the
+  recorded VAT and `shipping` the shipping lines' net.
+
+```ts
+const byProductType = (cs: readonly CategoryRefDto[]) => cs.find((c) => c.pathNames[0] === "Produkttyp");
+gtag("event", "view_item_list", { items: listing.items.map((card, index) => toGa4Item(card, { index, pickCategory: byProductType })) });
+gtag("event", "add_to_cart", { currency: cart.currency, items: [toGa4Item(line, { quantity: added })] });
+gtag("event", "purchase", toGa4Ecommerce(order, { pickCategory: byProductType }));
+```
+
 ### Search-as-you-type and search-in-facet
 
 `/v1/search/suggest` answers three short lists for what the shopper has typed so far: up to 5 product cards
@@ -412,6 +462,44 @@ Problem codes you will meet here: `CART_EMPTY`, `CHECKOUT_CART_CHANGED` (with `c
 
   `https://*.kustom.co` covers the playground (`js.playground.kustom.co`) and production (`js.kustom.co`).
 
+### Shipping
+
+The shopper chooses delivery inside the provider's widget (Kustom's shipping assistant, Qliro's shipping step), so
+there is **no shipping picker to build and no price, VAT or method id to send**. The `klarna-kco` (Kustom) and `qliro-q1`
+controllers answer for the widget; the page's part is the estimate before the checkout and the shipping block on the order.
+
+```ts
+// The estimate: an estimate, never a quote (the destination is not known yet). No lookup, `no-store`.
+const { data: estimate } = await storefront.GET("/v1/cart/shipping-estimate", {
+  params: { header: { "X-Cart-Token": token } },
+});
+if (estimate?.available) {
+  const headline = estimate.options.find((option) => option.preselected); // `fee` is gross kronor, "49.00"
+  // estimate.freeShipping: { free, threshold, remaining } — progress comes from here, never a hard-coded threshold
+}
+// `available: false` means show nothing about shipping. `reason: null`: no block published on the market, and the
+// checkout works as before. `reason: "unavailable"`: a block that cannot be served now; the cart works, but
+// POST /v1/checkout refuses a new attempt with 503 SHIPPING_UNAVAILABLE (Retry-After 60) until it is fixed.
+
+// The order page: `order.shipping` is `OrderShippingDto | null`.
+// null = the selection was not matched or confirmed (the charged shipping line is still in `order.lines`), or the
+// market has no block. Show the block only when it is present; never read null as "no shipping was paid".
+```
+
+- `ShippingEstimateOptionDto`: `key`, `name`, `deliveryType` (`delivery`, `pickup` or `mailbox`), `fee`, `regularFee`
+  (the price without the free-shipping rule; set only when `fee` is `"0.00"` and that price is above 0, so `null`
+  for an always-free method: render no comparison price then), `labels`, `pointsAtCheckout` (the pickup point is
+  chosen in the checkout; none is listed here) and `preselected`. The estimate has **no delivery time**.
+- `OrderShippingDto`: `option`, `name`, `deliveryType`, `carrier`, `fee`, `point` (name, street, postal code, city; null
+  when the carrier assigned it or after the privacy scrub) and `deliveryTime` (`mode` `carrierEstimate`, `fixed` or
+  `text`; `minDays` and `maxDays` are each nullable: render only the bounds that are present, or `text`).
+- **Do not re-render the widget** when shipping changes, and do not write your own Qliro unlock: on a market with a
+  shipping block Qliro's total includes the fee and so can differ from the cart's, and the `qliro-q1` controller unlocks on the echoed cart version
+  (`MerchantUpdateVersion`) or on the confirmed total (see the Qliro notes above).
+- Shipping never blocks a purchase. If a selection cannot be matched when the shopper pays, the order is accepted and
+  normally held in Asstio with its reason (rarely the export waits for an operator instead); the page has nothing to
+  do for it.
+
 ## Headers
 
 Every call the client makes carries these; you never set them by hand.

package/dist/analytics/decimal.d.ts

@@ -0,0 +1,13 @@
+/** An exact rational `n / d` (d > 0). Every API amount is a decimal string; nothing here ever goes through a float. */
+export type Rational = {
+    n: bigint;
+    d: bigint;
+};
+/** `"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. */
+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. */
+export declare function toCents(r: Rational): bigint;
+export declare const centsToNumber: (cents: bigint) => number;

package/dist/analytics/decimal.js

@@ -0,0 +1,29 @@
+import { AnalyticsError } from "./types.js";
+const DECIMAL = /^-?\d+(\.\d+)?$/;
+/** `"125.00"`, `"25"`, `"-3.5"` → an exact rational. Anything else (exponents, commas, blanks) throws. */
+export function parseDecimal(s) {
+    if (typeof s !== "string" || !DECIMAL.test(s))
+        throw new AnalyticsError(`not a decimal amount: "${s}"`);
+    const negative = s.startsWith("-");
+    const [whole, fraction = ""] = (negative ? s.slice(1) : s).split(".");
+    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. */
+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. */
+export function toCents(r) {
+    const num = r.n * 100n;
+    let q = num / r.d; // truncates toward zero
+    const rem = num % r.d;
+    const twice = 2n * (rem < 0n ? -rem : rem);
+    if (twice >= r.d)
+        q += num < 0n ? -1n : 1n;
+    return q;
+}
+export const centsToNumber = (cents) => Number(cents) / 100;

package/dist/analytics/facts.d.ts

@@ -0,0 +1,12 @@
+import { type CartLineDto, type OrderLineDto, type ProductCardDto, type ProductDto, type ProductFacts, type SelectedVariant } from "./types.js";
+/**
+ * The product facts of a card, a product page (with or without a selected variant), a cart line or an order line, so a
+ * frontend never needs to know where a surface keeps them. Returns the DTO's own arrays and objects — never copies,
+ * filters or mutates them. `brand` is the item's brand: a selected or purchased variant's own, with no fallback to the
+ * family brand (null can mean an explicit "none"). An order line that is not a product line throws.
+ */
+export declare function productFacts(source: ProductCardDto): ProductFacts;
+export declare function productFacts(source: ProductDto): ProductFacts;
+export declare function productFacts(source: SelectedVariant): ProductFacts;
+export declare function productFacts(source: CartLineDto): ProductFacts;
+export declare function productFacts(source: OrderLineDto): ProductFacts;

package/dist/analytics/facts.js

@@ -0,0 +1,30 @@
+import { AnalyticsError, } from "./types.js";
+export function productFacts(source) {
+    const s = source;
+    if (typeof s.type === "string") {
+        // An order line (checked first): the generated `type` is a plain string, so the product-line rule is checked here.
+        const line = source;
+        if (line.type !== "product" || !line.product || !line.variant)
+            throw new AnalyticsError(`an order line of type "${line.type}" has no product facts`);
+        return {
+            brand: line.variant.brand, productBrand: line.product.brand, categories: line.product.categories,
+            attributes: line.product.attributes, shortDescription: null,
+        };
+    }
+    if (isObject(s.product) && isObject(s.variant)) {
+        // A cart line or a selected-variant wrapper: the same fact paths.
+        const { product, variant } = source;
+        return {
+            brand: variant.brand, productBrand: product.brand, categories: product.categories,
+            attributes: product.attributes, shortDescription: product.shortDescription ?? null,
+        };
+    }
+    const flat = source;
+    if (!Array.isArray(flat.categories) || !Array.isArray(flat.attributes))
+        throw new AnalyticsError("not a product facts source");
+    return {
+        brand: flat.brand, productBrand: flat.brand, categories: flat.categories, attributes: flat.attributes,
+        shortDescription: flat.shortDescription ?? null,
+    };
+}
+const isObject = (v) => typeof v === "object" && v !== null;

package/dist/analytics/ga4.d.ts

@@ -0,0 +1,21 @@
+import { type CartDto, 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. */
+export type MappedItem = {
+    item: Ga4Item;
+    priceCents: bigint;
+};
+/**
+ * One GA4 item from a card (an impression: the family sku and from-price), a product with its selected variant, a cart
+ * line or a product order line. `item_brand` and the categories come from `productFacts`, so they never disagree with it.
+ * A source without a price throws — never `price: 0`.
+ */
+export declare function toGa4Item(source: Ga4ItemSource, opts?: Ga4ItemOptions): Ga4Item;
+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
+ * 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;
+export declare function toGa4Ecommerce(source: OrderDto, opts?: Ga4SharedOptions): Ga4Purchase;

package/dist/analytics/ga4.js

@@ -0,0 +1,111 @@
+import { add, centsToNumber, netOf, parseDecimal, toCents } from "./decimal.js";
+import { productFacts } from "./facts.js";
+import { AnalyticsError, } from "./types.js";
+/**
+ * One GA4 item from a card (an impression: the family sku and from-price), a product with its selected variant, a cart
+ * line or a product order line. `item_brand` and the categories come from `productFacts`, so they never disagree with it.
+ * A source without a price throws — never `price: 0`.
+ */
+export function toGa4Item(source, opts = {}) {
+    return mapItem(source, opts).item;
+}
+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 };
+    if (facts.brand)
+        item.item_brand = facts.brand.label;
+    const variant = itemVariant(line.options);
+    if (variant !== undefined)
+        item.item_variant = variant;
+    const picked = opts.pickCategory ? opts.pickCategory(facts.categories) : longest(facts.categories);
+    if (picked) {
+        const keys = ["item_category", "item_category2", "item_category3", "item_category4", "item_category5"];
+        picked.pathNames.slice(0, keys.length).forEach((name, i) => { item[keys[i]] = name; });
+    }
+    if (opts.index !== undefined)
+        item.index = opts.index;
+    if (opts.affiliation !== undefined)
+        item.affiliation = opts.affiliation;
+    if (opts.itemListId !== undefined)
+        item.item_list_id = opts.itemListId;
+    if (opts.itemListName !== undefined)
+        item.item_list_name = opts.itemListName;
+    return { item, priceCents };
+}
+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;
+    // 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) };
+    if (!isOrder)
+        return payload;
+    const order = source;
+    const include = opts.tax === "include";
+    const tax = include ? 0n : order.totals.vat.reduce((sum, v) => sum + toCents(parseDecimal(v.amount)), 0n);
+    const shippingLines = order.lines.filter(l => l.type === "shipping");
+    const shipping = include
+        ? shippingLines.reduce((sum, l) => sum + toCents(parseDecimal(l.lineTotalInc)), 0n)
+        : toCents(shippingLines.reduce((sum, l) => add(sum, netOf(parseDecimal(l.lineTotalInc), parseDecimal(l.vatRate))), { n: 0n, d: 1n }));
+    return { ...payload, transaction_id: order.id, tax: centsToNumber(tax), shipping: centsToNumber(shipping) };
+}
+function lineOf(source) {
+    const s = source;
+    if (typeof s.type === "string") {
+        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 };
+    }
+    if (typeof s.variant === "object" && s.variant !== null && "selectedOptions" in s.variant) {
+        if ("quantity" in s) {
+            const l = source;
+            return { id: l.sku, name: l.product.name, ...money(l.price), quantity: sourceQuantity(l.quantity), options: l.variant.selectedOptions };
+        }
+        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 };
+    }
+    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 };
+}
+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);
+    if (!Number.isFinite(n))
+        throw new AnalyticsError(`not a quantity: ${q}`);
+    return n;
+}
+/** add_to_cart/remove_from_cart: the positive whole number of units added or removed. */
+function checkedQuantity(q) {
+    if (!Number.isInteger(q) || q <= 0)
+        throw new AnalyticsError(`quantity must be a positive whole number, got ${q}`);
+    return q;
+}
+/** Options sorted ordinally by axis (never DTO order: jsonb does not keep key order), `"axis: value"` joined with ", ". */
+function itemVariant(options) {
+    if (!options)
+        return undefined;
+    const axes = Object.keys(options).sort();
+    return axes.length === 0 ? undefined : axes.map(a => `${a}: ${options[a]}`).join(", ");
+}
+/** The default pick: the longest path, the first of equals. Never mutates the array. */
+function longest(categories) {
+    let best;
+    for (const c of categories)
+        if (!best || c.pathNames.length > best.pathNames.length)
+            best = c;
+    return best;
+}

package/dist/analytics/types.d.ts

@@ -0,0 +1,86 @@
+import type { components } from "../schema";
+type Schemas = components["schemas"];
+export type ProductCardDto = Schemas["ProductCardDto"];
+export type ProductDto = Schemas["ProductDto"];
+export type VariantDto = Schemas["VariantDto"];
+export type CartDto = Schemas["CartDto"];
+export type CartLineDto = Schemas["CartLineDto"];
+export type OrderDto = Schemas["OrderDto"];
+export type OrderLineDto = Schemas["OrderLineDto"];
+export type BrandDto = Schemas["BrandDto"];
+export type CategoryRefDto = Schemas["CategoryRefDto"];
+export type AttributeDto = Schemas["AttributeDto"];
+export type PriceDto = Schemas["PriceDto"];
+/** A product page with the variant the shopper selected. */
+export type SelectedVariant = {
+    product: ProductDto;
+    variant: VariantDto;
+};
+/** The product facts of one source, whatever surface it came from (product facts spec §5.0). */
+export type ProductFacts = {
+    /** The item's brand: a card's (family) brand, else the selected or purchased variant's — never a fallback to the family's. */
+    brand: BrandDto | null;
+    /** The family brand on every source (on a card, the same as `brand`). */
+    productBrand: BrandDto | null;
+    /** Classification memberships with no primary meaning; `categories[0]` may be any root. */
+    categories: CategoryRefDto[];
+    /** As the source carries them: a `ProductDto` may include `html` attributes; cards, cart and order lines do not. */
+    attributes: AttributeDto[];
+    /** Null on order lines. */
+    shortDescription: string | null;
+};
+/** A source the analytics helpers cannot map: a non-product order line, an unpriced variant, an invalid quantity. */
+export declare class AnalyticsError extends Error {
+    name: string;
+}
+/** One GA4 ecommerce item. Members without a value are omitted, never `undefined`. */
+export type Ga4Item = {
+    item_id: string;
+    item_name: string;
+    item_brand?: string;
+    item_variant?: string;
+    item_category?: string;
+    item_category2?: string;
+    item_category3?: string;
+    item_category4?: string;
+    item_category5?: string;
+    /** Net of VAT by default (GA4 defines price without tax); gross with `tax: "include"`. */
+    price: number;
+    quantity: number;
+    index?: number;
+    affiliation?: string;
+    item_list_id?: string;
+    item_list_name?: string;
+};
+/** Options shared by every item of a payload. */
+export type Ga4SharedOptions = {
+    /** `"exclude"` (default): prices and value net of VAT, as GA4 defines them. `"include"`: gross, for shops that report gross revenue. */
+    tax?: "exclude" | "include";
+    affiliation?: string;
+    itemListId?: string;
+    itemListName?: string;
+    /** Which category feeds `item_category`…`item_category5`. Default: the longest path, ties in the order given. Returning
+     * `undefined` means no category fields — never a fallback to the default. Categories carry no primary meaning. */
+    pickCategory?: (categories: readonly CategoryRefDto[]) => CategoryRefDto | undefined;
+};
+/** One item's options: `quantity` overrides the source's (for add/remove events: the positive number of units added or
+ * removed), `itemId` its id (e.g. for family-level reporting), `index` its position in a list. */
+export type Ga4ItemOptions = Ga4SharedOptions & {
+    quantity?: number;
+    itemId?: string;
+    index?: number;
+};
+export type Ga4ItemSource = ProductCardDto | SelectedVariant | CartLineDto | OrderLineDto;
+/** `view_cart`, `begin_checkout` and the like. */
+export type Ga4Ecommerce = {
+    currency: string;
+    value: number;
+    items: Ga4Item[];
+};
+/** `purchase`: the order's payload. */
+export type Ga4Purchase = Ga4Ecommerce & {
+    transaction_id: string;
+    tax: number;
+    shipping: number;
+};
+export {};

package/dist/analytics/types.js

@@ -0,0 +1,4 @@
+/** A source the analytics helpers cannot map: a non-product order line, an unpriced variant, an invalid quantity. */
+export class AnalyticsError extends Error {
+    name = "AnalyticsError";
+}

package/dist/index.d.ts

@@ -56,4 +56,7 @@ export { brandHead, collectionHead, productHead, toNextMetadata } from "./seo/he
 export { gtinJsonLd } from "./gtin.js";
 export { productJsonLd } from "./seo/product.js";
 export { jsonLdScript } from "./seo/serialize.js";
+export { productFacts } from "./analytics/facts.js";
+export { toGa4Ecommerce, toGa4Item } from "./analytics/ga4.js";
+export { AnalyticsError, type Ga4Ecommerce, type Ga4Item, type Ga4ItemOptions, type Ga4ItemSource, type Ga4Purchase, type Ga4SharedOptions, type ProductFacts, type SelectedVariant, } from "./analytics/types.js";
 export { SeoError, type BreadcrumbLink, type CollectionHeadOptions, type HeadOptions, type JsonLd, type NextMetadataLike, type ProductJsonLdOptions, type SchemaProperty, type SeoContext, type SeoHead, type SeoMeta, type VariantAvailability, } from "./seo/types.js";

package/dist/index.js

@@ -45,4 +45,7 @@ export { brandHead, collectionHead, productHead, toNextMetadata } from "./seo/he
 export { gtinJsonLd } from "./gtin.js";
 export { productJsonLd } from "./seo/product.js";
 export { jsonLdScript } from "./seo/serialize.js";
+export { productFacts } from "./analytics/facts.js";
+export { toGa4Ecommerce, toGa4Item } from "./analytics/ga4.js";
+export { AnalyticsError, } from "./analytics/types.js";
 export { SeoError, } from "./seo/types.js";

package/dist/schema.d.ts

@@ -496,11 +496,16 @@ export interface components {
             variant: components["schemas"]["CartLineVariantDto"];
         };
         CartLineProductDto: {
+            attributes: components["schemas"]["AttributeDto"][];
+            brand: null | components["schemas"]["BrandDto"];
+            categories: components["schemas"]["CategoryRefDto"][];
             id: string;
             name: string;
+            shortDescription: null | string;
             slug: string;
         };
         CartLineVariantDto: {
+            brand: null | components["schemas"]["BrandDto"];
             id: string;
             selectedOptions: {
                 [key: string]: string;
@@ -833,15 +838,25 @@ export interface components {
             options: {
                 [key: string]: string;
             };
+            product: null | components["schemas"]["OrderLineProductDto"];
             productId: null | string;
             /** Format: int32 */
             quantity: number | string;
             sku: string;
             type: string;
             unitPriceInc: string;
+            variant: null | components["schemas"]["OrderLineVariantDto"];
             variantId: null | string;
             vatRate: string;
         };
+        OrderLineProductDto: {
+            attributes: components["schemas"]["AttributeDto"][];
+            brand: null | components["schemas"]["BrandDto"];
+            categories: components["schemas"]["CategoryRefDto"][];
+        };
+        OrderLineVariantDto: {
+            brand: null | components["schemas"]["BrandDto"];
+        };
         OrderShippingDto: {
             carrier: string;
             deliveryTime: null | components["schemas"]["DeliveryTimeDto"];
@@ -887,8 +902,10 @@ export interface components {
             vatRate: string;
         };
         ProductCardDto: {
+            attributes: components["schemas"]["AttributeDto"][];
             brand: null | components["schemas"]["BrandDto"];
             buyable: boolean;
+            categories: components["schemas"]["CategoryRefDto"][];
             collections: string[];
             id: string;
             image: null | components["schemas"]["MediaDescriptorDto"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asstio-dev/storefront",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "description": "Typed client for the Asstio Storefront API (generated from OpenAPI).",
   "repository": {
     "type": "git",
@@ -21,7 +21,7 @@
     "test": "vitest run",
     "test:browser": "playwright test -c browser/playwright.config.ts",
     "check": "npm run generate && npm run typecheck-examples && npm test && git diff --exit-code -- src/schema.d.ts && test -z \"$(git status --porcelain -- src/schema.d.ts)\"",
-    "smoke": "node --input-type=module -e \"import(\\\"./dist/index.js\\\").then(m => { for (const f of [\\\"createStorefrontClient\\\", \\\"filterQuery\\\", \\\"encodeFilterValues\\\", \\\"decodeFilterValues\\\", \\\"pictureSources\\\", \\\"mediaUrl\\\", \\\"formatImage\\\", \\\"styleToCss\\\", \\\"startCheckout\\\", \\\"syncCheckout\\\", \\\"completeCheckout\\\", \\\"getCheckoutStatus\\\", \\\"getOrder\\\", \\\"awaitCompletion\\\", \\\"mountCheckout\\\", \\\"productJsonLd\\\", \\\"gtinJsonLd\\\", \\\"breadcrumbJsonLd\\\", \\\"productHead\\\", \\\"collectionHead\\\", \\\"brandHead\\\", \\\"toNextMetadata\\\", \\\"jsonLdScript\\\", \\\"SeoError\\\"]) if (typeof m[f] !== \\\"function\\\") throw new Error(\\\"missing export \\\" + f) })\""
+    "smoke": "node --input-type=module -e \"import(\\\"./dist/index.js\\\").then(m => { for (const f of [\\\"createStorefrontClient\\\", \\\"filterQuery\\\", \\\"encodeFilterValues\\\", \\\"decodeFilterValues\\\", \\\"pictureSources\\\", \\\"mediaUrl\\\", \\\"formatImage\\\", \\\"styleToCss\\\", \\\"startCheckout\\\", \\\"syncCheckout\\\", \\\"completeCheckout\\\", \\\"getCheckoutStatus\\\", \\\"getOrder\\\", \\\"awaitCompletion\\\", \\\"mountCheckout\\\", \\\"productJsonLd\\\", \\\"gtinJsonLd\\\", \\\"breadcrumbJsonLd\\\", \\\"productHead\\\", \\\"collectionHead\\\", \\\"brandHead\\\", \\\"toNextMetadata\\\", \\\"jsonLdScript\\\", \\\"SeoError\\\", \\\"productFacts\\\", \\\"toGa4Item\\\", \\\"toGa4Ecommerce\\\", \\\"AnalyticsError\\\"]) if (typeof m[f] !== \\\"function\\\") throw new Error(\\\"missing export \\\" + f) })\""
   },
   "dependencies": {
     "openapi-fetch": "0.17.0"

package/src/schema.d.ts

@@ -496,11 +496,16 @@ export interface components {
             variant: components["schemas"]["CartLineVariantDto"];
         };
         CartLineProductDto: {
+            attributes: components["schemas"]["AttributeDto"][];
+            brand: null | components["schemas"]["BrandDto"];
+            categories: components["schemas"]["CategoryRefDto"][];
             id: string;
             name: string;
+            shortDescription: null | string;
             slug: string;
         };
         CartLineVariantDto: {
+            brand: null | components["schemas"]["BrandDto"];
             id: string;
             selectedOptions: {
                 [key: string]: string;
@@ -833,15 +838,25 @@ export interface components {
             options: {
                 [key: string]: string;
             };
+            product: null | components["schemas"]["OrderLineProductDto"];
             productId: null | string;
             /** Format: int32 */
             quantity: number | string;
             sku: string;
             type: string;
             unitPriceInc: string;
+            variant: null | components["schemas"]["OrderLineVariantDto"];
             variantId: null | string;
             vatRate: string;
         };
+        OrderLineProductDto: {
+            attributes: components["schemas"]["AttributeDto"][];
+            brand: null | components["schemas"]["BrandDto"];
+            categories: components["schemas"]["CategoryRefDto"][];
+        };
+        OrderLineVariantDto: {
+            brand: null | components["schemas"]["BrandDto"];
+        };
         OrderShippingDto: {
             carrier: string;
             deliveryTime: null | components["schemas"]["DeliveryTimeDto"];
@@ -887,8 +902,10 @@ export interface components {
             vatRate: string;
         };
         ProductCardDto: {
+            attributes: components["schemas"]["AttributeDto"][];
             brand: null | components["schemas"]["BrandDto"];
             buyable: boolean;
+            categories: components["schemas"]["CategoryRefDto"][];
             collections: string[];
             id: string;
             image: null | components["schemas"]["MediaDescriptorDto"];