@hartl-services/medusa-storefront 0.1.0 → 0.3.0

package/README.md

@@ -73,6 +73,30 @@ The copied files belong to the shop: style them, rename them, change the
 wording. Keep the commerce logic in the package — a fix there reaches the shop
 with the next version; a fix only in a copied file does not.
 
+## Optional actions
+
+Some server functions are optional in `createStorefrontBrowser`'s `actions`,
+so a shop wired before they existed keeps working. Add the `"use server"`
+wrapper (as in the `setup` item's `lib/storefront/actions.ts`) to use them:
+
+| Action | Since | Used by |
+|---|---|---|
+| `registerCustomerWithProfile` | 0.2.0 | `usePasswordAuth().registerWithProfile` (name, phone, default address) |
+| `getOrder` | 0.2.0 | `useAccountOrderDetail` (order lines and totals in the account) |
+| `registerPartnerWithProfile` | 0.3.0 | `usePasswordAuth().registerPartner` (account, company address with optional UID, partner application) |
+
+## Partner views (e.g. therapists)
+
+A partner is an approved affiliate. For server rendering,
+`storefront.affiliate.isActivePartner()` answers whether the logged-in
+customer is one (`loadPartnerPortalState()` gives the full state, e.g.
+`pending` for a submitted application). Both are cached per request and fail
+closed: logged out, partner portal switched off or an unreachable backend all
+count as "not a partner". A partner registration (`registerPartner`) creates
+the account with the company address as default address and submits the
+application from it; while the e-mail is unconfirmed, both wait until the
+first login.
+
 ## Wiring rules
 
 - Create `createStorefrontServer` and `createStorefrontBrowser` once each, at

package/dist/browser/actions.d.ts

@@ -15,6 +15,10 @@ export interface StorefrontActions {
     loginCustomer: Server["customer"]["loginCustomer"];
     checkCustomerVerification: Server["customer"]["checkCustomerVerification"];
     registerCustomer: Server["customer"]["registerCustomer"];
+    /** Optional (since 0.2.0): registration with name, phone and address. */
+    registerCustomerWithProfile?: Server["customer"]["registerCustomerWithProfile"];
+    /** Optional (since 0.3.0): partner registration with company address and partner application. */
+    registerPartnerWithProfile?: Server["customer"]["registerPartnerWithProfile"];
     requestLoginCode: Server["customer"]["requestLoginCode"];
     loginWithCode: Server["customer"]["loginWithCode"];
     requestCustomerPasswordReset: Server["customer"]["requestCustomerPasswordReset"];
@@ -44,6 +48,8 @@ export interface StorefrontActions {
     revokeAffiliateCouponCode: Server["affiliate"]["revokeAffiliateCouponCode"];
     createConsignmentReport: Server["affiliate"]["createConsignmentReport"];
     listOrders: Server["orders"]["listOrders"];
+    /** Optional (since 0.2.0): one order with lines and totals (account order detail). */
+    getOrder?: Server["orders"]["getOrder"];
     listDocuments: Server["documents"]["listDocuments"];
 }
 export {};

package/dist/browser/cart-mutations.d.ts

@@ -25,8 +25,9 @@ export declare function createCartMutations({ actions, createClient, referral, r
     }>;
     completeCart(cartId: string): Promise<HttpTypes.StoreCompleteCartResponse>;
     /** Adds one unit of a variant, creating the cart first when there is none. */
-    addProductToCart({ activeCart, regionId, variantId }: {
+    addProductToCart({ activeCart, quantity, regionId, variantId }: {
         activeCart: Pick<HttpTypes.StoreCart, "id"> | null;
+        quantity?: number;
         regionId: string;
         variantId: string;
     }): Promise<Pick<HttpTypes.StoreCart, "id">>;

package/dist/browser/cart-mutations.js

@@ -125,10 +125,10 @@ export function createCartMutations({ actions, createClient, referral, reportChe
             return result;
         },
         /** Adds one unit of a variant, creating the cart first when there is none. */
-        async addProductToCart({ activeCart, regionId, variantId }) {
+        async addProductToCart({ activeCart, quantity = 1, regionId, variantId }) {
             const cart = activeCart ?? (await createCart({ region_id: regionId }));
             await addCartLineItem(cart.id, {
-                quantity: 1,
+                quantity,
                 variant_id: variantId,
             });
             return cart;

package/dist/browser/index.d.ts

@@ -79,8 +79,9 @@ export declare function createStorefrontBrowser(config: StorefrontBrowserConfig)
             ready: true;
         }>;
         completeCart(cartId: string): Promise<HttpTypes.StoreCompleteCartResponse>;
-        addProductToCart({ activeCart, regionId, variantId }: {
+        addProductToCart({ activeCart, quantity, regionId, variantId }: {
             activeCart: Pick<HttpTypes.StoreCart, "id"> | null;
+            quantity?: number;
             regionId: string;
             variantId: string;
         }): Promise<Pick<HttpTypes.StoreCart, "id">>;
@@ -253,6 +254,9 @@ export declare function createStorefrontBrowser(config: StorefrontBrowserConfig)
             limit: number;
             offset: number;
         }], HttpTypes.StoreOrderListResponse, Error>;
+        orderDetail: (orderId: string) => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<HttpTypes.StoreOrder | null, Error, HttpTypes.StoreOrder | null, readonly ["medusa", "orders", "detail", string]>, "queryFn"> & {
+            queryFn?: import("@tanstack/react-query").QueryFunction<HttpTypes.StoreOrder | null, readonly ["medusa", "orders", "detail", string], never> | undefined;
+        } & import("@tanstack/react-query").QueryKeyWithDataTag<readonly ["medusa", "orders", "detail", string], HttpTypes.StoreOrder | null, Error>;
         customerPasswordPolicy: () => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
             min_length: number;
             require_mixed_case: boolean;

package/dist/browser/query-keys.d.ts

@@ -11,6 +11,7 @@ export declare const medusaQueryKeys: {
         limit: number;
         offset: number;
     }];
+    orderDetail: (orderId: string) => readonly ["medusa", "orders", "detail", string];
     ordersAll: () => readonly ["medusa", "orders"];
     paymentProviders: (regionId: string) => readonly ["medusa", "payment-providers", string];
     pluginFeatures: () => readonly ["medusa", "plugin-features"];

package/dist/browser/query-keys.js

@@ -4,6 +4,8 @@ export const medusaQueryKeys = {
     customerPasswordPolicy: () => ["medusa", "customer-password-policy"],
     documents: () => ["medusa", "documents"],
     orders: (page) => ["medusa", "orders", page],
+    // Under ordersAll, so everything that resets the orders resets a detail too.
+    orderDetail: (orderId) => ["medusa", "orders", "detail", orderId],
     ordersAll: () => ["medusa", "orders"],
     paymentProviders: (regionId) => ["medusa", "payment-providers", regionId],
     pluginFeatures: () => ["medusa", "plugin-features"],

package/dist/browser/query-options.d.ts

@@ -111,6 +111,10 @@ export declare function createQueryOptions({ actions, affiliateApiPaths, cart, r
         limit: number;
         offset: number;
     }], import("@medusajs/types").StoreOrderListResponse, Error>;
+    /** One order with its lines and totals; needs the optional `getOrder` action. */
+    orderDetail: (orderId: string) => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<import("@medusajs/types").StoreOrder | null, Error, import("@medusajs/types").StoreOrder | null, readonly ["medusa", "orders", "detail", string]>, "queryFn"> & {
+        queryFn?: import("@tanstack/react-query").QueryFunction<import("@medusajs/types").StoreOrder | null, readonly ["medusa", "orders", "detail", string], never> | undefined;
+    } & import("@tanstack/react-query").QueryKeyWithDataTag<readonly ["medusa", "orders", "detail", string], import("@medusajs/types").StoreOrder | null, Error>;
     customerPasswordPolicy: () => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<{
         min_length: number;
         require_mixed_case: boolean;

package/dist/browser/query-options.js

@@ -78,6 +78,12 @@ export function createQueryOptions({ actions, affiliateApiPaths, cart, referral,
             queryKey: medusaQueryKeys.orders({ limit, offset }),
             queryFn: () => actions.listOrders({ limit, offset }),
         }),
+        /** One order with its lines and totals; needs the optional `getOrder` action. */
+        orderDetail: (orderId) => queryOptions({
+            queryKey: medusaQueryKeys.orderDetail(orderId),
+            queryFn: async () => (actions.getOrder ? await actions.getOrder(orderId) : null),
+            enabled: Boolean(actions.getOrder) && Boolean(orderId),
+        }),
         customerPasswordPolicy: () => queryOptions({
             queryKey: medusaQueryKeys.customerPasswordPolicy(),
             queryFn: () => actions.fetchCustomerPasswordPolicy(),

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/partner-only.d.ts

@@ -0,0 +1,18 @@
+import type { HttpTypes } from "@medusajs/types";
+import type { CategoryTreeNode } from "./category-filter.js";
+/** A category tree node with the metadata that carries the partner-only flag. */
+export type PartnerCategoryTreeNode = CategoryTreeNode & {
+    category_children?: PartnerCategoryTreeNode[] | null;
+    metadata?: Record<string, unknown> | null;
+};
+/** Ids of every flagged category and all its descendants. */
+export declare function collectPartnerOnlyCategoryIds(trees: PartnerCategoryTreeNode[]): Set<string>;
+/** The trees without flagged categories (and their subcategories) - what a non-partner sees. */
+export declare function withoutPartnerOnlyCategories<T extends PartnerCategoryTreeNode>(trees: T[]): T[];
+/**
+ * A product only active partners may see and order: tagged
+ * `PARTNER_ONLY_PRODUCT_TAG` or in a partner-only category (see
+ * `collectPartnerOnlyCategoryIds`). The backend enforces the same rule when
+ * the cart is completed.
+ */
+export declare function isPartnerOnlyProduct(product: Pick<HttpTypes.StoreProduct, "categories" | "tags">, partnerOnlyCategoryIds: ReadonlySet<string>): boolean;

package/dist/core/catalog/partner-only.js

@@ -0,0 +1,31 @@
+import { PARTNER_ONLY_CATEGORY_METADATA_KEY, PARTNER_ONLY_PRODUCT_TAG } from "@hartl-services/medusa-contracts/paths/affiliate";
+import { collectCategoryIds } from "./category-filter.js";
+function isFlagged(category) {
+    return category.metadata?.[PARTNER_ONLY_CATEGORY_METADATA_KEY] === true;
+}
+/** Ids of every flagged category and all its descendants. */
+export function collectPartnerOnlyCategoryIds(trees) {
+    const ids = new Set();
+    const visit = (node) => {
+        if (isFlagged(node)) {
+            collectCategoryIds(node).forEach((id) => ids.add(id));
+            return;
+        }
+        node.category_children?.forEach(visit);
+    };
+    trees.forEach(visit);
+    return ids;
+}
+/** The trees without flagged categories (and their subcategories) - what a non-partner sees. */
+export function withoutPartnerOnlyCategories(trees) {
+    return trees.filter((node) => !isFlagged(node)).map((node) => (node.category_children ? { ...node, category_children: withoutPartnerOnlyCategories(node.category_children) } : node));
+}
+/**
+ * A product only active partners may see and order: tagged
+ * `PARTNER_ONLY_PRODUCT_TAG` or in a partner-only category (see
+ * `collectPartnerOnlyCategoryIds`). The backend enforces the same rule when
+ * the cart is completed.
+ */
+export function isPartnerOnlyProduct(product, partnerOnlyCategoryIds) {
+    return (product.tags ?? []).some((tag) => tag.value === PARTNER_ONLY_PRODUCT_TAG) || (product.categories ?? []).some((category) => partnerOnlyCategoryIds.has(category.id));
+}

package/dist/core/form-values.d.ts

@@ -10,6 +10,94 @@ export declare function createCustomerRegistrationSchema(t: Translate, policy: C
     email: z.ZodString;
     password: z.ZodString;
 }, z.core.$strip>;
+/** The address a registration may carry (stored as the customer's default address). */
+export declare const registrationAddressSchema: z.ZodObject<{
+    address_1: z.ZodString;
+    city: z.ZodString;
+    company: z.ZodOptional<z.ZodString>;
+    country_code: z.ZodString;
+    postal_code: z.ZodString;
+    vat_number: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** What the server takes for a registration with profile (and optional address). */
+export declare const customerRegistrationProfileSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    address: z.ZodOptional<z.ZodObject<{
+        address_1: z.ZodString;
+        city: z.ZodString;
+        company: z.ZodOptional<z.ZodString>;
+        country_code: z.ZodString;
+        postal_code: z.ZodString;
+        vat_number: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    phone: z.ZodString;
+}, z.core.$strip>;
+/**
+ * A partner (e.g. therapist) registration: the profile with a complete
+ * company address - with a UID, or with the confirmation that the company has
+ * none - from which the partner application is submitted.
+ */
+export declare const partnerRegistrationProfileSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    phone: z.ZodString;
+    address: z.ZodObject<{
+        address_1: z.ZodString;
+        city: z.ZodString;
+        country_code: z.ZodString;
+        postal_code: z.ZodString;
+        vat_number: z.ZodOptional<z.ZodString>;
+        company: z.ZodString;
+    }, z.core.$strip>;
+    confirmed_without_vat_number: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * The registration form with profile, address, a repeated password and the
+ * accepted terms. Address fields are all-or-nothing: none or a complete
+ * address.
+ */
+export declare function createCustomerRegistrationFormSchema(t: Translate, policy: CustomerPasswordPolicy | null): z.ZodObject<{
+    accept_terms: z.ZodBoolean;
+    address_1: z.ZodString;
+    city: z.ZodString;
+    confirmPassword: z.ZodString;
+    country_code: z.ZodString;
+    email: z.ZodString;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    password: z.ZodString;
+    phone: z.ZodString;
+    postal_code: z.ZodString;
+}, z.core.$strip>;
+/**
+ * The partner registration form: profile and a required company address,
+ * an optional UID, and without UID the confirmation that the company has none.
+ */
+export declare function createPartnerRegistrationFormSchema(t: Translate, policy: CustomerPasswordPolicy | null): z.ZodObject<{
+    address_1: z.ZodString;
+    city: z.ZodString;
+    company: z.ZodString;
+    confirmed_without_vat_number: z.ZodBoolean;
+    country_code: z.ZodString;
+    postal_code: z.ZodString;
+    vat_number: z.ZodString;
+    accept_terms: z.ZodBoolean;
+    confirmPassword: z.ZodString;
+    email: z.ZodString;
+    first_name: z.ZodString;
+    last_name: z.ZodString;
+    password: z.ZodString;
+    phone: z.ZodString;
+}, z.core.$strip>;
+/** The partner registration form's values as the server takes them. */
+export declare function toPartnerRegistrationProfile(value: PartnerRegistrationFormValues): PartnerRegistrationProfileValues;
+/** The registration form's values as the server takes them. */
+export declare function toRegistrationProfile(value: CustomerRegistrationFormValues): CustomerRegistrationProfileValues;
 export declare function createPasswordResetSchema(t: Translate, policy: CustomerPasswordPolicy | null): z.ZodObject<{
     confirmPassword: z.ZodString;
     password: z.ZodString;
@@ -85,31 +173,35 @@ export declare const createCheckoutAddressSchema: (t: Translate, merchantCountry
     has_different_billing_address: z.ZodBoolean;
     shipping_address: z.ZodObject<{
         address_1: z.ZodString;
-        address_2: z.ZodString;
         city: z.ZodString;
         company: z.ZodString;
         country_code: z.ZodString;
+        postal_code: z.ZodString;
         first_name: z.ZodString;
         last_name: z.ZodString;
         phone: z.ZodString;
-        postal_code: z.ZodString;
+        address_2: z.ZodString;
         province: z.ZodString;
     }, z.core.$strip>;
     billing_address: z.ZodObject<{
         address_1: z.ZodString;
-        address_2: z.ZodString;
         city: z.ZodString;
         company: z.ZodString;
         country_code: z.ZodString;
+        postal_code: z.ZodString;
         first_name: z.ZodString;
         last_name: z.ZodString;
         phone: z.ZodString;
-        postal_code: z.ZodString;
+        address_2: z.ZodString;
         province: z.ZodString;
     }, z.core.$strip>;
     vat_number: z.ZodString;
 }, z.core.$strip>;
 export type CustomerAuthValues = z.infer<typeof customerAuthSchema>;
+export type CustomerRegistrationProfileValues = z.infer<typeof customerRegistrationProfileSchema>;
+export type CustomerRegistrationFormValues = z.infer<ReturnType<typeof createCustomerRegistrationFormSchema>>;
+export type PartnerRegistrationProfileValues = z.infer<typeof partnerRegistrationProfileSchema>;
+export type PartnerRegistrationFormValues = z.infer<ReturnType<typeof createPartnerRegistrationFormSchema>>;
 export type LoginCodeRequestValues = z.infer<ReturnType<typeof createLoginCodeRequestSchema>>;
 export type PasswordResetValues = z.infer<ReturnType<typeof createPasswordResetSchema>>;
 export type VerificationResendValues = z.infer<ReturnType<typeof createVerificationResendSchema>>;

package/dist/core/form-values.js

@@ -27,6 +27,137 @@ export function createCustomerRegistrationSchema(t, policy) {
         password: createNewPasswordSchema(t, policy),
     });
 }
+/** The address a registration may carry (stored as the customer's default address). */
+export const registrationAddressSchema = z.object({
+    address_1: z.string().trim().min(1),
+    city: z.string().trim().min(1),
+    company: z.string().trim().optional(),
+    country_code: z.string().trim().min(1),
+    postal_code: z.string().trim().min(1),
+    /** Stored in the address metadata, where the UID check reads it. */
+    vat_number: z.string().trim().optional(),
+});
+/** What the server takes for a registration with profile (and optional address). */
+export const customerRegistrationProfileSchema = customerAuthSchema.extend({
+    address: registrationAddressSchema.optional(),
+    first_name: z.string().trim().min(1),
+    last_name: z.string().trim().min(1),
+    phone: z.string().trim(),
+});
+/**
+ * A partner (e.g. therapist) registration: the profile with a complete
+ * company address - with a UID, or with the confirmation that the company has
+ * none - from which the partner application is submitted.
+ */
+export const partnerRegistrationProfileSchema = customerRegistrationProfileSchema
+    .extend({
+    address: registrationAddressSchema.extend({ company: z.string().trim().min(1) }),
+    confirmed_without_vat_number: z.boolean(),
+})
+    .refine((value) => Boolean(value.address.vat_number) || value.confirmed_without_vat_number, { path: ["confirmed_without_vat_number"] });
+function registrationFormFields(t, policy) {
+    return {
+        accept_terms: z.boolean().refine((accepted) => accepted, t("registration.terms_required")),
+        address_1: z.string().trim(),
+        city: z.string().trim(),
+        confirmPassword: z.string(),
+        country_code: z.string().trim(),
+        email: z.string().trim().min(1, t("form.email_required")).email(t("form.email_invalid")),
+        first_name: z.string().trim().min(1, t("address.first_name_required")),
+        last_name: z.string().trim().min(1, t("address.last_name_required")),
+        password: createNewPasswordSchema(t, policy),
+        phone: z.string().trim(),
+        postal_code: z.string().trim(),
+    };
+}
+/**
+ * The registration form with profile, address, a repeated password and the
+ * accepted terms. Address fields are all-or-nothing: none or a complete
+ * address.
+ */
+export function createCustomerRegistrationFormSchema(t, policy) {
+    return z
+        .object(registrationFormFields(t, policy))
+        .superRefine((value, context) => {
+        if (value.password !== value.confirmPassword) {
+            context.addIssue({ code: "custom", message: t("form.passwords_mismatch"), path: ["confirmPassword"] });
+        }
+        const addressFields = [
+            ["address_1", "address.address_1_required"],
+            ["postal_code", "address.postal_code_required"],
+            ["city", "address.city_required"],
+            ["country_code", "address.country_required"],
+        ];
+        if (addressFields.some(([field]) => value[field])) {
+            for (const [field, code] of addressFields) {
+                if (!value[field]) {
+                    context.addIssue({ code: "custom", message: t(code), path: [field] });
+                }
+            }
+        }
+    });
+}
+/**
+ * The partner registration form: profile and a required company address,
+ * an optional UID, and without UID the confirmation that the company has none.
+ */
+export function createPartnerRegistrationFormSchema(t, policy) {
+    return z
+        .object({
+        ...registrationFormFields(t, policy),
+        address_1: z.string().trim().min(1, t("address.address_1_required")),
+        city: z.string().trim().min(1, t("address.city_required")),
+        company: z.string().trim().min(1, t("company_address.company_required")),
+        confirmed_without_vat_number: z.boolean(),
+        country_code: z.string().trim().min(1, t("address.country_required")),
+        postal_code: z.string().trim().min(1, t("address.postal_code_required")),
+        vat_number: z.string().refine((value) => {
+            const vatNumber = value.replace(/\s+/g, "");
+            return !vatNumber || (vatNumber.length >= 4 && vatNumber.length <= 32);
+        }, t("company_address.vat_number_invalid")),
+    })
+        .superRefine((value, context) => {
+        if (value.password !== value.confirmPassword) {
+            context.addIssue({ code: "custom", message: t("form.passwords_mismatch"), path: ["confirmPassword"] });
+        }
+        if (!value.vat_number.trim() && !value.confirmed_without_vat_number) {
+            context.addIssue({ code: "custom", message: t("affiliate_application.confirm_without_vat_number"), path: ["confirmed_without_vat_number"] });
+        }
+    });
+}
+/** The partner registration form's values as the server takes them. */
+export function toPartnerRegistrationProfile(value) {
+    const vatNumber = value.vat_number.replace(/\s+/g, "").toUpperCase();
+    return {
+        address: {
+            address_1: value.address_1.trim(),
+            city: value.city.trim(),
+            company: value.company.trim(),
+            country_code: value.country_code.trim().toLowerCase(),
+            postal_code: value.postal_code.trim(),
+            ...(vatNumber ? { vat_number: vatNumber } : {}),
+        },
+        // Only meaningful without a UID; the backend ignores it otherwise.
+        confirmed_without_vat_number: !vatNumber && value.confirmed_without_vat_number,
+        email: value.email.trim(),
+        first_name: value.first_name.trim(),
+        last_name: value.last_name.trim(),
+        password: value.password,
+        phone: value.phone.trim(),
+    };
+}
+/** The registration form's values as the server takes them. */
+export function toRegistrationProfile(value) {
+    const hasAddress = Boolean(value.address_1 && value.postal_code && value.city && value.country_code);
+    return {
+        email: value.email.trim(),
+        first_name: value.first_name.trim(),
+        last_name: value.last_name.trim(),
+        password: value.password,
+        phone: value.phone.trim(),
+        ...(hasAddress ? { address: { address_1: value.address_1.trim(), city: value.city.trim(), country_code: value.country_code.trim().toLowerCase(), postal_code: value.postal_code.trim() } } : {}),
+    };
+}
 export function createPasswordResetSchema(t, policy) {
     return z
         .object({

package/dist/core/index.d.ts

@@ -17,6 +17,8 @@ export * from "./cart/cart-tax-breakdown.js";
 export * from "./cart/coupon-promotions.js";
 export * from "./cart/payment-session.js";
 export * from "./cart/refunded-cart.js";
+export * from "./catalog/category-filter.js";
+export * from "./catalog/partner-only.js";
 export * from "./catalog/inventory.js";
 export * from "./catalog/medusa-product-image.js";
 export * from "./catalog/product-price.js";

package/dist/core/index.js

@@ -18,6 +18,8 @@ export * from "./cart/cart-tax-breakdown.js";
 export * from "./cart/coupon-promotions.js";
 export * from "./cart/payment-session.js";
 export * from "./cart/refunded-cart.js";
+export * from "./catalog/category-filter.js";
+export * from "./catalog/partner-only.js";
 export * from "./catalog/inventory.js";
 export * from "./catalog/medusa-product-image.js";
 export * from "./catalog/product-price.js";

package/dist/core/report-error.d.ts

@@ -1,5 +1,5 @@
 /** Where an error happened; the shop's error tracker files it under this area. */
-export type StorefrontErrorArea = "checkout" | "customer-auth" | "plugin-features" | "tax-compliance";
+export type StorefrontErrorArea = "affiliate" | "checkout" | "customer-auth" | "plugin-features" | "tax-compliance";
 export interface StorefrontErrorReport {
     area: StorefrontErrorArea;
     /** Extra data for tracing (cart id, status, ...); never addresses or payment details. */

package/dist/core/texts-de.d.ts

@@ -6,6 +6,10 @@
 export declare const textsDe: {
     readonly "form.password_required": "Bitte gib ein Passwort ein.";
     readonly "form.passwords_mismatch": "Die Passwörter stimmen nicht überein.";
+    readonly "registration.terms_required": "Bitte akzeptiere die Nutzungsbedingungen und Datenschutzrichtlinien.";
+    readonly "registration.address_not_saved": "Dein Konto wurde angelegt, die Adresse konnte aber nicht gespeichert werden. Du kannst sie in deinem Konto nachtragen.";
+    readonly "partner_registration.unavailable": "Die Registrierung als Partner ist derzeit nicht möglich.";
+    readonly "partner_registration.application_not_submitted": "Dein Konto wurde angelegt, die Bewerbung konnte aber nicht übermittelt werden. Bitte melde dich bei uns.";
     readonly "form.email_required": "Bitte gib deine E-Mail-Adresse ein.";
     readonly "form.email_invalid": "Bitte gib eine gültige E-Mail-Adresse ein.";
     readonly "form.login_code_invalid": "Bitte gib den {length}-stelligen Code ein.";

package/dist/core/texts-de.js

@@ -8,6 +8,10 @@ export const textsDe = {
     // Forms
     "form.password_required": "Bitte gib ein Passwort ein.",
     "form.passwords_mismatch": "Die Passwörter stimmen nicht überein.",
+    "registration.terms_required": "Bitte akzeptiere die Nutzungsbedingungen und Datenschutzrichtlinien.",
+    "registration.address_not_saved": "Dein Konto wurde angelegt, die Adresse konnte aber nicht gespeichert werden. Du kannst sie in deinem Konto nachtragen.",
+    "partner_registration.unavailable": "Die Registrierung als Partner ist derzeit nicht möglich.",
+    "partner_registration.application_not_submitted": "Dein Konto wurde angelegt, die Bewerbung konnte aber nicht übermittelt werden. Bitte melde dich bei uns.",
     "form.email_required": "Bitte gib deine E-Mail-Adresse ein.",
     "form.email_invalid": "Bitte gib eine gültige E-Mail-Adresse ein.",
     "form.login_code_invalid": "Bitte gib den {length}-stelligen Code ein.",

package/dist/react/use-account.d.ts

@@ -76,6 +76,16 @@ export declare function useAccountOrders(): {
     isPending: boolean;
     orders: HttpTypes.StoreOrder[];
 };
+/**
+ * One order of the account with its lines and totals, loaded when it is
+ * opened (the list carries only the total). Needs the shop's optional
+ * `getOrder` action; `null` loads nothing.
+ */
+export declare function useAccountOrderDetail(orderId: string | null): {
+    isError: boolean;
+    isPending: boolean;
+    order: HttpTypes.StoreOrder | null;
+};
 /** The account's address book page: add, edit (with the UID check), delete and default addresses. */
 export declare function useAccountAddresses(): {
     addressBook: {

package/dist/react/use-account.js

@@ -145,6 +145,16 @@ export function useAccountOrders() {
         orders: ordersResponse?.orders ?? [],
     };
 }
+/**
+ * One order of the account with its lines and totals, loaded when it is
+ * opened (the list carries only the total). Needs the shop's optional
+ * `getOrder` action; `null` loads nothing.
+ */
+export function useAccountOrderDetail(orderId) {
+    const { queries } = useStorefront();
+    const { data: order, isError, isFetching } = useQuery({ ...queries.orderDetail(orderId ?? ""), enabled: Boolean(orderId) && queries.orderDetail(orderId ?? "").enabled !== false });
+    return { isError, isPending: Boolean(orderId) && isFetching && !order, order: order ?? null };
+}
 /** The account's address book page: add, edit (with the UID check), delete and default addresses. */
 export function useAccountAddresses() {
     const { actions, t, unwrapMedusaAction } = useStorefront();

package/dist/react/use-auth.d.ts

@@ -1,5 +1,5 @@
 import type { StorefrontBrowser } from "../browser/index.js";
-import type { CustomerAuthValues, PasswordResetValues, VerificationResendValues } from "../core/form-values.js";
+import type { CustomerAuthValues, CustomerRegistrationProfileValues, PartnerRegistrationProfileValues, PasswordResetValues, VerificationResendValues } from "../core/form-values.js";
 /**
  * Start of the backend's 400 for a registration with an address that already
  * has an account; the form then links to the password reset.
@@ -48,6 +48,21 @@ export declare function usePasswordAuth({ getValues, onSuccess }: PasswordAuthOp
     cancelVerification: () => void;
     login: (value: CustomerAuthValues) => Promise<boolean>;
     register: (value: CustomerAuthValues) => Promise<boolean>;
+    /** The registration did not store its address; the account exists (add it in the account). */
+    isAddressNotSaved: boolean;
+    /**
+     * Registration with name, phone and address; needs the shop's optional
+     * `registerCustomerWithProfile` action. True once signed in.
+     */
+    registerWithProfile(value: CustomerRegistrationProfileValues): Promise<boolean>;
+    /** The partner registration did not submit its application; the account exists. */
+    isApplicationNotSubmitted: boolean;
+    /**
+     * Partner registration with company address; the application follows
+     * (after an e-mail confirmation: at the first login). Needs the shop's
+     * optional `registerPartnerWithProfile` action. True once signed in.
+     */
+    registerPartner(value: PartnerRegistrationProfileValues): Promise<boolean>;
     /** "I confirmed it": signs in again with the kept form values, also after a registration (the account exists by now). */
     continueAfterVerification(): Promise<void>;
 };