@hartl-services/medusa-storefront 0.0.0-stage → 0.2.0

package/dist/core/auth/customer-sign-in.d.ts

@@ -0,0 +1,36 @@
+import type Medusa from "@medusajs/js-sdk";
+type MedusaClient = Medusa;
+export interface CustomerSignInDependencies {
+    /** Client that sends the given token as bearer authorization. */
+    createAuthenticatedClient: (token: string) => MedusaClient;
+    /** Claims the active cart for the customer; called with a client carrying the final token. */
+    transferCart: (sdk: MedusaClient, customer: {
+        email: string;
+        id: string;
+    }) => Promise<unknown>;
+    /** Stores the final token in the HttpOnly session cookie. */
+    storeToken: (token: string) => Promise<void>;
+}
+/**
+ * Password login with one fallback: accounts restored via "Passwort vergessen"
+ * are stored with a lowercase address, older ones keep the spelling they were
+ * registered with. A 401 for an address with uppercase letters is therefore
+ * retried once with the lowercased address. Returns the address that worked.
+ */
+export declare function loginWithEmailpass(sdk: MedusaClient, credentials: {
+    email: string;
+    password: string;
+}): Promise<{
+    email: string;
+    result: import("@medusajs/js-sdk").AuthLoginResponse;
+}>;
+/**
+ * Shared end of every sign-in that ends with a valid token: make sure the
+ * customer exists (and the token carries it), claim the active cart and store
+ * the final token in the cookie. Nothing is stored when a step fails.
+ */
+export declare function completeCustomerSignIn(token: string, email: string, dependencies: CustomerSignInDependencies): Promise<{
+    state: "success";
+    sessionToken: string;
+}>;
+export {};

package/dist/core/auth/customer-sign-in.js

@@ -0,0 +1,55 @@
+import { FetchError } from "@medusajs/js-sdk";
+import { StorefrontError } from "../errors.js";
+/**
+ * Password login with one fallback: accounts restored via "Passwort vergessen"
+ * are stored with a lowercase address, older ones keep the spelling they were
+ * registered with. A 401 for an address with uppercase letters is therefore
+ * retried once with the lowercased address. Returns the address that worked.
+ */
+export async function loginWithEmailpass(sdk, credentials) {
+    try {
+        return { email: credentials.email, result: await sdk.auth.login("customer", "emailpass", credentials) };
+    }
+    catch (error) {
+        const lowercased = credentials.email.toLowerCase();
+        if (!(error instanceof FetchError) || error.status !== 401 || lowercased === credentials.email) {
+            throw error;
+        }
+        return { email: lowercased, result: await sdk.auth.login("customer", "emailpass", { ...credentials, email: lowercased }) };
+    }
+}
+async function ensureCustomerAccount(email, sdk) {
+    try {
+        const response = await sdk.store.customer.retrieve();
+        return { created: false, customer: response.customer };
+    }
+    catch {
+        const { customer } = await sdk.store.customer.create({ email });
+        return { created: true, customer };
+    }
+}
+// A token issued before the customer existed has no customer id; only the
+// refreshed token carries it, and only that one may reach the cookie and the
+// browser session (otherwise later cart calls from the browser are blocked).
+async function refreshAuthenticationToken(sdk) {
+    const refreshed = await sdk.auth.refresh();
+    if (typeof refreshed === "object" && "token" in refreshed && typeof refreshed.token === "string") {
+        return refreshed.token;
+    }
+    throw new StorefrontError("auth.unsupported_step");
+}
+/**
+ * Shared end of every sign-in that ends with a valid token: make sure the
+ * customer exists (and the token carries it), claim the active cart and store
+ * the final token in the cookie. Nothing is stored when a step fails.
+ */
+export async function completeCustomerSignIn(token, email, dependencies) {
+    const { createAuthenticatedClient, storeToken, transferCart } = dependencies;
+    const { created, customer } = await ensureCustomerAccount(email, createAuthenticatedClient(token));
+    const finalToken = created ? await refreshAuthenticationToken(createAuthenticatedClient(token)) : token;
+    await transferCart(createAuthenticatedClient(finalToken), { id: customer.id, email });
+    await storeToken(finalToken);
+    // Returned so the browser can open its Medusa session (browser-session.ts);
+    // it is used once there and never stored client-side.
+    return { state: "success", sessionToken: finalToken };
+}

package/dist/core/auth/link-token.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reads the token from the fragment of an e-mail link: the password reset
+ * (`/<countryCode>/reset-password#token=...`) and the account verification
+ * (`/<countryCode>/verify-account#token=...`). The e-mail plugin puts the token
+ * into the fragment on purpose: browsers never send it to a server, so it
+ * cannot end up in access logs or referrers.
+ */
+export declare function readLinkToken(hash: string): string | undefined;

package/dist/core/auth/link-token.js

@@ -0,0 +1,11 @@
+/**
+ * Reads the token from the fragment of an e-mail link: the password reset
+ * (`/<countryCode>/reset-password#token=...`) and the account verification
+ * (`/<countryCode>/verify-account#token=...`). The e-mail plugin puts the token
+ * into the fragment on purpose: browsers never send it to a server, so it
+ * cannot end up in access logs or referrers.
+ */
+export function readLinkToken(hash) {
+    const token = new URLSearchParams(hash.replace(/^#/, "")).get("token")?.trim();
+    return token ? token : undefined;
+}

package/dist/core/auth/login-code-auto-send.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Whether a login code must be sent on its own now. `lastSentFor` is the
+ * address the component already sent one to (kept in a ref, so a re-render or
+ * React's StrictMode double effect does not send twice); the backend throttles
+ * on top of that.
+ */
+export declare function shouldAutoSendLoginCode(lastSentFor: string | null, email: string): boolean;

package/dist/core/auth/login-code-auto-send.js

@@ -0,0 +1,11 @@
+import { normalizeLoginEmail } from "@hartl-services/medusa-contracts/schemas/customer-auth";
+/**
+ * Whether a login code must be sent on its own now. `lastSentFor` is the
+ * address the component already sent one to (kept in a ref, so a re-render or
+ * React's StrictMode double effect does not send twice); the backend throttles
+ * on top of that.
+ */
+export function shouldAutoSendLoginCode(lastSentFor, email) {
+    const normalizedEmail = normalizeLoginEmail(email);
+    return normalizedEmail !== "" && normalizedEmail !== lastSentFor;
+}

package/dist/core/auth/password-rule-label.d.ts

@@ -0,0 +1,4 @@
+import type { CustomerPasswordPolicy, PasswordRuleKey } from "@hartl-services/medusa-contracts/schemas/password-policy";
+import type { Translate } from "../i18n.js";
+/** Checklist text of one password rule; the length rule names the shop's minimum. */
+export declare function getPasswordRuleLabel(rule: PasswordRuleKey, policy: CustomerPasswordPolicy, t: Translate): string;

package/dist/core/auth/password-rule-label.js

@@ -0,0 +1,13 @@
+/** Checklist text of one password rule; the length rule names the shop's minimum. */
+export function getPasswordRuleLabel(rule, policy, t) {
+    switch (rule) {
+        case "min_length":
+            return t("password_rule.min_length", { count: policy.min_length });
+        case "mixed_case":
+            return t("password_rule.mixed_case");
+        case "digit":
+            return t("password_rule.digit");
+        case "symbol":
+            return t("password_rule.symbol");
+    }
+}

package/dist/core/cart/cart-line-item-image-url.d.ts

@@ -0,0 +1,9 @@
+import type { HttpTypes } from "@medusajs/types";
+type LineItemWithImageSources = HttpTypes.StoreCartLineItem | HttpTypes.StoreOrderLineItem;
+/**
+ * The fixed image priority for cart and order lines: variant thumbnail, first
+ * usable variant image, item thumbnail, product thumbnail, first usable
+ * product image. Empty strings count as missing, so they fall through.
+ */
+export declare function getCartLineItemImageUrl(item: LineItemWithImageSources): string | null;
+export {};

package/dist/core/cart/cart-line-item-image-url.js

@@ -0,0 +1,14 @@
+const usable = (url) => (url?.trim() ? url : undefined);
+/**
+ * The fixed image priority for cart and order lines: variant thumbnail, first
+ * usable variant image, item thumbnail, product thumbnail, first usable
+ * product image. Empty strings count as missing, so they fall through.
+ */
+export function getCartLineItemImageUrl(item) {
+    return (usable(item.variant?.thumbnail) ??
+        item.variant?.images?.map((image) => usable(image.url)).find(Boolean) ??
+        usable(item.thumbnail) ??
+        usable(item.product?.thumbnail) ??
+        item.product?.images?.map((image) => usable(image.url)).find(Boolean) ??
+        null);
+}

package/dist/core/cart/cart-normalization.d.ts

@@ -0,0 +1,2 @@
+import type { HttpTypes } from "@medusajs/types";
+export declare function normalizeStoreCart(cart: HttpTypes.StoreCart): HttpTypes.StoreCart;

package/dist/core/cart/cart-normalization.js

@@ -0,0 +1,11 @@
+// Medusa's `deletePromotionsWorkflow` soft-deletes without removing the
+// `cart_promotion` link, so the store cart response can contain `null`
+// promotion entries. This is the single place where the cart is normalized
+// before any component sees it - do not add `?.` guards downstream.
+export function normalizeStoreCart(cart) {
+    const promotions = (cart.promotions ?? []);
+    return {
+        ...cart,
+        promotions: promotions.filter((promotion) => Boolean(promotion?.id)),
+    };
+}

package/dist/core/cart/cart-price-breakdown.d.ts

@@ -0,0 +1,30 @@
+import type { HttpTypes } from "@medusajs/types";
+type PriceBreakdownSource = Pick<HttpTypes.StoreCart, "discount_total" | "gift_card_total" | "original_item_total" | "original_shipping_total" | "shipping_total" | "tax_total" | "total">;
+type PriceLineItemSource = Pick<HttpTypes.StoreCartLineItem, "discount_total" | "original_total" | "quantity" | "total" | "unit_price">;
+export declare function isZeroAmount(amount: number): boolean;
+export declare function getCartPriceBreakdown(cart: PriceBreakdownSource): {
+    discountTotal: number;
+    giftCardTotal: number;
+    itemTotal: number;
+    originalShippingTotal: number;
+    shippingTotal: number;
+    taxTotal: number;
+    total: number;
+};
+export declare function getCartLineItemPriceBreakdown(item: PriceLineItemSource): {
+    discountTotal: number;
+    originalTotal: number;
+    total: number;
+    unitPrice: number;
+};
+type ShippingMethodSource = Pick<HttpTypes.StoreCartShippingMethod, "original_total" | "shipping_option_id" | "total">;
+/**
+ * The selected shipping option shows what the cart actually charges for it
+ * (e.g. 0 after a free-shipping promotion), with the list price as original;
+ * every other option shows its list price.
+ */
+export declare function getShippingOptionPrice(optionId: string, optionAmount: number | null | undefined, shippingMethod: ShippingMethodSource | undefined): {
+    amount: number;
+    originalAmount: number | undefined;
+} | null;
+export {};

package/dist/core/cart/cart-price-breakdown.js

@@ -0,0 +1,45 @@
+// Medusa's totals are floats (4.9 - 4.8999999999999995); anything below half a
+// cent is a rounding artefact, not an amount.
+const AMOUNT_EPSILON = 0.005;
+export function isZeroAmount(amount) {
+    return Math.abs(amount) < AMOUNT_EPSILON;
+}
+export function getCartPriceBreakdown(cart) {
+    // A shipping discount (e.g. automatic free shipping) is shown on the
+    // shipping line as discounted shipping, so the discount line only keeps
+    // what was taken off the items.
+    const shippingDiscount = typeof cart.original_shipping_total === "number" && typeof cart.shipping_total === "number" ? Math.max(cart.original_shipping_total - cart.shipping_total, 0) : 0;
+    const itemDiscount = (cart.discount_total ?? 0) - shippingDiscount;
+    return {
+        discountTotal: isZeroAmount(itemDiscount) ? 0 : itemDiscount,
+        giftCardTotal: cart.gift_card_total,
+        itemTotal: cart.original_item_total,
+        originalShippingTotal: cart.original_shipping_total,
+        shippingTotal: cart.shipping_total,
+        taxTotal: cart.tax_total,
+        total: cart.total,
+    };
+}
+export function getCartLineItemPriceBreakdown(item) {
+    const originalTotal = item.original_total ?? item.unit_price * item.quantity;
+    const total = item.total ?? originalTotal;
+    const calculatedDiscount = Math.max(originalTotal - total, 0);
+    return {
+        discountTotal: item.discount_total && item.discount_total > 0 ? item.discount_total : calculatedDiscount,
+        originalTotal,
+        total,
+        unitPrice: item.unit_price,
+    };
+}
+/**
+ * The selected shipping option shows what the cart actually charges for it
+ * (e.g. 0 after a free-shipping promotion), with the list price as original;
+ * every other option shows its list price.
+ */
+export function getShippingOptionPrice(optionId, optionAmount, shippingMethod) {
+    if (shippingMethod?.shipping_option_id === optionId && typeof shippingMethod.total === "number") {
+        const originalTotal = shippingMethod.original_total;
+        return { amount: shippingMethod.total, originalAmount: typeof originalTotal === "number" && originalTotal > shippingMethod.total ? originalTotal : undefined };
+    }
+    return typeof optionAmount === "number" ? { amount: optionAmount, originalAmount: undefined } : null;
+}

package/dist/core/cart/cart-tax-breakdown.d.ts

@@ -0,0 +1,17 @@
+interface TaxLineSource {
+    rate: number | null;
+    total: number;
+}
+interface TaxableSource {
+    tax_lines?: TaxLineSource[] | null;
+}
+interface TaxBreakdownSource {
+    items?: TaxableSource[] | null;
+    shipping_methods?: TaxableSource[] | null;
+}
+export interface TaxRateBreakdownLine {
+    amount: number;
+    rate: number;
+}
+export declare function getTaxRateBreakdown(source: TaxBreakdownSource): TaxRateBreakdownLine[];
+export {};

package/dist/core/cart/cart-tax-breakdown.js

@@ -0,0 +1,18 @@
+export function getTaxRateBreakdown(source) {
+    const amountByRate = new Map();
+    const addTaxLines = (taxLines) => {
+        for (const taxLine of taxLines ?? []) {
+            if (typeof taxLine.rate !== "number" || !Number.isFinite(taxLine.rate)) {
+                continue;
+            }
+            amountByRate.set(taxLine.rate, (amountByRate.get(taxLine.rate) ?? 0) + taxLine.total);
+        }
+    };
+    for (const item of source.items ?? []) {
+        addTaxLines(item.tax_lines);
+    }
+    for (const shippingMethod of source.shipping_methods ?? []) {
+        addTaxLines(shippingMethod.tax_lines);
+    }
+    return [...amountByRate.entries()].map(([rate, amount]) => ({ amount, rate })).sort((a, b) => b.rate - a.rate);
+}

package/dist/core/cart/coupon-promotions.d.ts

@@ -0,0 +1,8 @@
+import type { HttpTypes } from "@medusajs/types";
+type CouponPromotionSource = Pick<HttpTypes.StoreCart, "items" | "promotions" | "shipping_methods">;
+/**
+ * The promotions shown as a coupon. An automatic promotion that only adjusts
+ * shipping (free shipping) is not one: it shows as discounted shipping instead.
+ */
+export declare function getCouponPromotions(cart: CouponPromotionSource): HttpTypes.StoreCartPromotion[];
+export {};

package/dist/core/cart/coupon-promotions.js

@@ -0,0 +1,9 @@
+/**
+ * The promotions shown as a coupon. An automatic promotion that only adjusts
+ * shipping (free shipping) is not one: it shows as discounted shipping instead.
+ */
+export function getCouponPromotions(cart) {
+    const itemPromotionIds = new Set((cart.items ?? []).flatMap((item) => item.adjustments ?? []).map((adjustment) => adjustment.promotion_id));
+    const shippingPromotionIds = new Set((cart.shipping_methods ?? []).flatMap((method) => method.adjustments ?? []).map((adjustment) => adjustment.promotion_id));
+    return cart.promotions.filter((promotion) => !(promotion.is_automatic && shippingPromotionIds.has(promotion.id) && !itemPromotionIds.has(promotion.id)));
+}

package/dist/core/cart/payment-session.d.ts

@@ -0,0 +1,3 @@
+import type { HttpTypes } from "@medusajs/types";
+export declare function isPaymentSessionOutdated(cart: Pick<HttpTypes.StoreCart, "currency_code" | "total">, session: Pick<HttpTypes.StorePaymentSession, "amount" | "currency_code">): boolean;
+export declare function findPendingPaymentSession(cart: Pick<HttpTypes.StoreCart, "payment_collection">): HttpTypes.StorePaymentSession | undefined;

package/dist/core/cart/payment-session.js

@@ -0,0 +1,12 @@
+// A session still for the cart's total and currency charges the right amount;
+// re-initiating it would only create a new PaymentIntent and reload Stripe
+// Elements for nothing.
+export function isPaymentSessionOutdated(cart, session) {
+    return session.amount !== cart.total || session.currency_code.toLowerCase() !== cart.currency_code.toLowerCase();
+}
+// A "requires_more" session is a 3DS flow already in progress and must not be
+// torn down by an unrelated cart-price change (e.g. a quantity bump) - only a
+// still-pending session is safe to re-initiate.
+export function findPendingPaymentSession(cart) {
+    return cart.payment_collection?.payment_sessions?.find((session) => session.status === "pending");
+}

package/dist/core/cart/refunded-cart.d.ts

@@ -0,0 +1,27 @@
+import type { HttpTypes } from "@medusajs/types";
+/** Cart metadata key naming the refunded cart a replacement cart was created for. */
+export declare const REPLACED_REFUNDED_CART_METADATA_KEY = "replaced_refunded_cart_id";
+type RefundCheckCart = Pick<HttpTypes.StoreCart, "completed_at" | "payment_collection">;
+type ReplacementSourceCart = Pick<HttpTypes.StoreCart, "billing_address" | "email" | "id" | "items" | "region_id" | "shipping_address">;
+/**
+ * Stripe captures on confirmation, so a cart completion failing afterwards
+ * makes Medusa refund the payment. It then cannot delete the session of the
+ * succeeded PaymentIntent, so the cart stays open with it: every cart change
+ * fails ("Could not delete all payment sessions") and the backend refuses to
+ * complete it. Such a cart is replaced, never repaired. A payment whose refund
+ * failed is still captured and keeps the "Bestellung abschließen" retry.
+ */
+export declare function hasRefundedPayment(cart: RefundCheckCart): boolean;
+/**
+ * The cart that takes over from a refunded one: same region, items, e-mail
+ * and addresses. Coupon codes follow separately (getCustomerCouponCodes); the
+ * own-order promotion is applied again when the payment step starts.
+ */
+export declare function buildReplacementCart(cart: ReplacementSourceCart): HttpTypes.StoreCreateCart;
+export declare function isRefundReplacementCart(cart: Pick<HttpTypes.StoreCart, "metadata">): boolean;
+/**
+ * The codes the customer entered on the refunded cart, to apply again on its
+ * replacement. Automatic promotions apply by themselves.
+ */
+export declare function getCustomerCouponCodes(cart: Pick<HttpTypes.StoreCart, "promotions">): string[];
+export {};

package/dist/core/cart/refunded-cart.js

@@ -0,0 +1,46 @@
+import { toCartAddress } from "../addresses.js";
+/** Cart metadata key naming the refunded cart a replacement cart was created for. */
+export const REPLACED_REFUNDED_CART_METADATA_KEY = "replaced_refunded_cart_id";
+/**
+ * Stripe captures on confirmation, so a cart completion failing afterwards
+ * makes Medusa refund the payment. It then cannot delete the session of the
+ * succeeded PaymentIntent, so the cart stays open with it: every cart change
+ * fails ("Could not delete all payment sessions") and the backend refuses to
+ * complete it. Such a cart is replaced, never repaired. A payment whose refund
+ * failed is still captured and keeps the "Bestellung abschließen" retry.
+ */
+export function hasRefundedPayment(cart) {
+    return !cart.completed_at && (cart.payment_collection?.refunded_amount ?? 0) > 0;
+}
+function toReplacementAddress(address) {
+    if (!address) {
+        return undefined;
+    }
+    // The metadata carries the billing UID (tax-compliance).
+    return address.metadata ? { ...toCartAddress(address), metadata: address.metadata } : toCartAddress(address);
+}
+/**
+ * The cart that takes over from a refunded one: same region, items, e-mail
+ * and addresses. Coupon codes follow separately (getCustomerCouponCodes); the
+ * own-order promotion is applied again when the payment step starts.
+ */
+export function buildReplacementCart(cart) {
+    return {
+        billing_address: toReplacementAddress(cart.billing_address),
+        email: cart.email ?? undefined,
+        items: (cart.items ?? []).flatMap((item) => (item.variant_id ? [{ quantity: item.quantity, variant_id: item.variant_id }] : [])),
+        metadata: { [REPLACED_REFUNDED_CART_METADATA_KEY]: cart.id },
+        region_id: cart.region_id,
+        shipping_address: toReplacementAddress(cart.shipping_address),
+    };
+}
+export function isRefundReplacementCart(cart) {
+    return typeof cart.metadata?.[REPLACED_REFUNDED_CART_METADATA_KEY] === "string";
+}
+/**
+ * The codes the customer entered on the refunded cart, to apply again on its
+ * replacement. Automatic promotions apply by themselves.
+ */
+export function getCustomerCouponCodes(cart) {
+    return cart.promotions.flatMap((promotion) => (promotion.code && !promotion.is_automatic ? [promotion.code] : []));
+}

package/dist/core/catalog/category-filter.d.ts

@@ -0,0 +1,16 @@
+import type { HttpTypes } from "@medusajs/types";
+/** A category with the descendants Medusa returns for `include_descendants_tree`. */
+export type CategoryTreeNode = Pick<HttpTypes.StoreProductCategory, "id" | "handle" | "name"> & {
+    category_children?: CategoryTreeNode[] | null;
+};
+/** The category and all its descendants: choosing a parent filter includes its subcategories. */
+export declare function collectCategoryIds(category: CategoryTreeNode): string[];
+/** The node with this handle anywhere in the trees, or null. */
+export declare function findCategoryByHandle(trees: CategoryTreeNode[], handle: string): CategoryTreeNode | null;
+/**
+ * Keeps the products that match every selected filter: a product matches one
+ * filter when it belongs to the chosen category or one of its descendants.
+ * Medusa's `category_id` is an OR list, so two filters at once (e.g. an
+ * application area AND an ingredient group) are intersected here.
+ */
+export declare function filterProductsByCategories<T extends Pick<HttpTypes.StoreProduct, "categories">>(products: T[], selected: CategoryTreeNode[]): T[];

package/dist/core/catalog/category-filter.js

@@ -0,0 +1,33 @@
+/** The category and all its descendants: choosing a parent filter includes its subcategories. */
+export function collectCategoryIds(category) {
+    return [category.id, ...(category.category_children ?? []).flatMap(collectCategoryIds)];
+}
+/** The node with this handle anywhere in the trees, or null. */
+export function findCategoryByHandle(trees, handle) {
+    for (const node of trees) {
+        if (node.handle === handle) {
+            return node;
+        }
+        const match = findCategoryByHandle(node.category_children ?? [], handle);
+        if (match) {
+            return match;
+        }
+    }
+    return null;
+}
+/**
+ * Keeps the products that match every selected filter: a product matches one
+ * filter when it belongs to the chosen category or one of its descendants.
+ * Medusa's `category_id` is an OR list, so two filters at once (e.g. an
+ * application area AND an ingredient group) are intersected here.
+ */
+export function filterProductsByCategories(products, selected) {
+    if (selected.length === 0) {
+        return products;
+    }
+    const filters = selected.map((category) => new Set(collectCategoryIds(category)));
+    return products.filter((product) => {
+        const productCategoryIds = (product.categories ?? []).map((category) => category.id);
+        return filters.every((filter) => productCategoryIds.some((id) => filter.has(id)));
+    });
+}

package/dist/core/catalog/inventory.d.ts

@@ -0,0 +1,10 @@
+import type { HttpTypes } from "@medusajs/types";
+type InventorySource = Pick<HttpTypes.StoreProductVariant, "allow_backorder" | "inventory_quantity" | "manage_inventory">;
+/**
+ * A variant is out of stock only when all three hold: inventory is managed,
+ * backorders are not allowed, and nothing is left. A bare
+ * `inventory_quantity <= 0` check wrongly blocks a variant whose inventory is
+ * not managed or that may be backordered.
+ */
+export declare function isVariantOutOfStock(variant: InventorySource): boolean;
+export {};

package/dist/core/catalog/inventory.js

@@ -0,0 +1,9 @@
+/**
+ * A variant is out of stock only when all three hold: inventory is managed,
+ * backorders are not allowed, and nothing is left. A bare
+ * `inventory_quantity <= 0` check wrongly blocks a variant whose inventory is
+ * not managed or that may be backordered.
+ */
+export function isVariantOutOfStock(variant) {
+    return variant.manage_inventory === true && variant.allow_backorder !== true && typeof variant.inventory_quantity === "number" && variant.inventory_quantity <= 0;
+}

package/dist/core/catalog/medusa-product-image.d.ts

@@ -0,0 +1,8 @@
+import type { HttpTypes } from "@medusajs/types";
+interface MedusaProductImage {
+    alt: string;
+    url: string;
+}
+export declare function getMedusaProductImages(product: Pick<HttpTypes.StoreProduct, "images" | "thumbnail" | "title">): MedusaProductImage[];
+export declare function getMedusaProductImage(product: Pick<HttpTypes.StoreProduct, "images" | "thumbnail" | "title">): MedusaProductImage | null;
+export {};

package/dist/core/catalog/medusa-product-image.js

@@ -0,0 +1,13 @@
+export function getMedusaProductImages(product) {
+    const imageUrls = new Set();
+    return [product.thumbnail, ...(product.images ?? []).map((image) => image.url)].flatMap((url) => {
+        if (!url || imageUrls.has(url)) {
+            return [];
+        }
+        imageUrls.add(url);
+        return [{ alt: product.title, url }];
+    });
+}
+export function getMedusaProductImage(product) {
+    return getMedusaProductImages(product)[0] ?? null;
+}

package/dist/core/catalog/product-price.d.ts

@@ -0,0 +1,8 @@
+import type { HttpTypes } from "@medusajs/types";
+interface ProductPrice {
+    amount: number;
+    currencyCode: string;
+    originalAmount: number | null;
+}
+export declare function getProductPrice(product: Pick<HttpTypes.StoreProduct, "variants">): ProductPrice | null;
+export {};

package/dist/core/catalog/product-price.js

@@ -0,0 +1,21 @@
+export function getProductPrice(product) {
+    const prices = (product.variants ?? []).flatMap((variant) => {
+        const calculatedPrice = variant.calculated_price;
+        if (typeof calculatedPrice?.calculated_amount !== "number" || typeof calculatedPrice.currency_code !== "string") {
+            return [];
+        }
+        const grossAmount = typeof calculatedPrice.calculated_amount_with_tax === "number" ? calculatedPrice.calculated_amount_with_tax : calculatedPrice.calculated_amount;
+        const grossOriginalAmount = typeof calculatedPrice.original_amount_with_tax === "number" ? calculatedPrice.original_amount_with_tax : calculatedPrice.original_amount;
+        return [
+            {
+                amount: grossAmount,
+                currencyCode: calculatedPrice.currency_code,
+                originalAmount: typeof grossOriginalAmount === "number" ? grossOriginalAmount : null,
+            },
+        ];
+    });
+    if (prices.length === 0) {
+        return null;
+    }
+    return prices.reduce((lowestPrice, price) => (price.amount < lowestPrice.amount ? price : lowestPrice));
+}

package/dist/core/catalog/selected-variant.d.ts

@@ -0,0 +1,7 @@
+import type { HttpTypes } from "@medusajs/types";
+/**
+ * The variant the product page shows and sells: the one from `?v_id`, or the
+ * first variant when the id is missing or unknown. Shared by the price and the
+ * cart button so both always refer to the same variant.
+ */
+export declare function resolveSelectedVariant(variants: HttpTypes.StoreProductVariant[] | null | undefined, selectedVariantId: string | undefined): HttpTypes.StoreProductVariant | undefined;

package/dist/core/catalog/selected-variant.js

@@ -0,0 +1,9 @@
+/**
+ * The variant the product page shows and sells: the one from `?v_id`, or the
+ * first variant when the id is missing or unknown. Shared by the price and the
+ * cart button so both always refer to the same variant.
+ */
+export function resolveSelectedVariant(variants, selectedVariantId) {
+    const list = variants ?? [];
+    return list.find((variant) => variant.id === selectedVariantId) ?? list[0];
+}

package/dist/core/checkout/checkout-account-offer-state.d.ts

@@ -0,0 +1,41 @@
+export type AccountOfferStep = "ask" | "code" | "declined" | "done";
+export interface AccountOfferState {
+    /** Normalized address the step belongs to ("" while the cart has none). */
+    email: string;
+    step: AccountOfferStep;
+}
+export type AccountOfferAction = {
+    type: "accepted";
+} | {
+    type: "cancelled";
+} | {
+    type: "declined";
+} | {
+    email: string;
+    type: "emailChanged";
+} | {
+    type: "reconsidered";
+} | {
+    type: "signedIn";
+};
+export declare function normalizeOfferEmail(email: string | null | undefined): string;
+export declare function createAccountOfferState(email: string | null | undefined): AccountOfferState;
+export declare function accountOfferReducer(state: AccountOfferState, action: AccountOfferAction): AccountOfferState;
+export interface AccountOfferVisibilityInput {
+    /** The shop offers the e-mail code login (customer_auth.email_otp). */
+    codeLoginEnabled: boolean;
+    /** The e-mail on the cart. */
+    email: string | null | undefined;
+    /**
+     * The e-mail field's current value. While it differs from the cart (typed
+     * but not yet written on blur), the offer hides, so "yes" can never mail a
+     * code to the previous address.
+     */
+    fieldEmail: string;
+    /** The customer query settled and found nobody logged in. */
+    isGuest: boolean;
+    /** The checkout currently demands a login for the e-mail (the login prompt replaces the form). */
+    isLoginRequired: boolean;
+    step: AccountOfferStep;
+}
+export declare function isAccountOfferVisible({ codeLoginEnabled, email, fieldEmail, isGuest, isLoginRequired, step }: AccountOfferVisibilityInput): boolean;