@viu/emporix-sdk-react 1.0.0

package/dist/hooks.d.ts

@@ -0,0 +1,529 @@
+import { Customer, AuthContext, Product, PaginatedItems, Category, CategoryNode, Cart, CartItemInput, CartItemUpdate, CartAddress, CartCreated, CreateCartInput, CheckoutResult, CheckoutInput, QuoteCheckoutInput, PaymentMode, PriceMatchByContextInput, PriceMatch, Media, SegmentCategoryTree, SegmentItem, Segment, PasswordChangeInput, CustomerUpdateInput, Address, AddressCreateInput, AddressUpdateInput, PasswordResetRequestInput, PasswordResetConfirmInput, Site, LegalEntity, ContactAssignment, Location, IamGroup, ContactAssignmentCreate, LegalEntityCreate, LocationCreate, LegalEntityUpdate, ContactAssignmentUpdate, LocationUpdate, OrderStatus, Order, SalesOrderPatch } from '@viu/emporix-sdk';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryResult, UseInfiniteQueryResult, UseMutationResult } from '@tanstack/react-query';
+import { S as SiteContextValue } from './provider-fvcYdqqX.js';
+import 'react';
+import './storage.js';
+
+/** Customer authentication state and actions. */
+interface CustomerSessionApi {
+    customerToken: string | null;
+    customer: Customer | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    /** Current refresh token (in-session; set by `login`). */
+    refreshToken: string | null;
+    login: (input: {
+        email: string;
+        password: string;
+    }) => Promise<void>;
+    signup: (input: {
+        email: string;
+        password: string;
+    }) => Promise<void>;
+    /** Authorization-Code SSO: exchanges an IdP `code` for a customer session. */
+    socialLogin: (input: {
+        code: string;
+        redirectUri: string;
+        codeVerifier?: string;
+        sessionId?: string;
+    }) => Promise<void>;
+    /** RFC 8693 token exchange: exchanges an external IdP JWT for a session. */
+    exchangeToken: (input: {
+        subjectToken: string;
+        config?: string;
+    }) => Promise<void>;
+    /** Server-side logout (best-effort), then clears the local session. */
+    logout: () => Promise<void>;
+    /** Refetches the `me` profile query. */
+    refresh: () => Promise<void>;
+    /**
+     * Exchanges the stored refresh token for a fresh customer token (same
+     * sessionId) and updates the stored token. No-op if there is no refresh
+     * token. Throws if the refresh itself fails.
+     */
+    refreshSession: () => Promise<void>;
+}
+/** Manages the customer session: login/signup/logout and the `me` query. */
+declare function useCustomerSession(): CustomerSessionApi;
+
+/** Options accepted by every read hook to override the per-call auth context. */
+interface QueryOpts {
+    auth?: AuthContext;
+}
+
+/** Fetches one product. Default auth: customer if logged in, else anonymous. */
+declare function useProduct(productId: string, options?: QueryOpts): UseQueryResult<Product>;
+/** Fetches one page of products. */
+declare function useProducts(params?: {
+    pageNumber?: number;
+    pageSize?: number;
+}, options?: QueryOpts): UseQueryResult<PaginatedItems<Product>>;
+/** Infinite product list — terminates on `hasNextPage=false`. */
+declare function useProductsInfinite(params?: {
+    pageSize?: number;
+}, options?: QueryOpts): UseInfiniteQueryResult<{
+    pages: PaginatedItems<Product>[];
+    pageParams: number[];
+}>;
+/** Fetches one product by its `code` (URL slug). Disabled when code is empty. */
+declare function useProductByCode(code: string | undefined, options?: QueryOpts): UseQueryResult<Product>;
+/** Full-text product search. Disabled when query is empty/whitespace. */
+declare function useProductSearch(query: string | undefined, params?: {
+    pageNumber?: number;
+    pageSize?: number;
+}, options?: QueryOpts): UseQueryResult<PaginatedItems<Product>>;
+
+/** Fetches one category. */
+declare function useCategory(categoryId: string, options?: QueryOpts): UseQueryResult<Category>;
+/** Fetches one page of categories. */
+declare function useCategories(params?: {
+    pageNumber?: number;
+    pageSize?: number;
+}, options?: QueryOpts): UseQueryResult<PaginatedItems<Category>>;
+/** Infinite category list — terminates on `hasNextPage=false`. */
+declare function useCategoriesInfinite(params?: {
+    pageSize?: number;
+}, options?: QueryOpts): UseInfiniteQueryResult<{
+    pages: PaginatedItems<Category>[];
+    pageParams: number[];
+}>;
+/** Fetches the category tree. */
+declare function useCategoryTree(rootId?: string, options?: QueryOpts): UseQueryResult<CategoryNode>;
+/** One page of products in a category. Disabled when categoryId is empty. */
+declare function useProductsInCategory(categoryId: string | undefined, params?: {
+    pageNumber?: number;
+    pageSize?: number;
+}, options?: QueryOpts): UseQueryResult<PaginatedItems<Product>>;
+/** Infinite-scroll product list for a category. Terminates on `hasNextPage=false`. */
+declare function useProductsInCategoryInfinite(categoryId: string | undefined, params?: {
+    pageSize?: number;
+}, options?: QueryOpts): UseInfiniteQueryResult<{
+    pages: PaginatedItems<Product>[];
+    pageParams: number[];
+}>;
+
+/** Fetches a cart by id. Falls back to `storage.getCartId()` when no argument is passed; disabled when neither is set. */
+declare function useCart(cartId?: string, options?: QueryOpts): UseQueryResult<Cart>;
+type Mut<TVars> = UseMutationResult<Cart, unknown, TVars, {
+    previous: Cart | undefined;
+}>;
+/** Cart write operations with optimistic cache updates and rollback. */
+interface CartMutationsApi {
+    addItem: Mut<CartItemInput>;
+    updateItem: Mut<{
+        itemId: string;
+        patch: CartItemUpdate;
+    }>;
+    removeItem: Mut<{
+        itemId: string;
+    }>;
+    clear: Mut<void>;
+    applyCoupon: Mut<{
+        code: string;
+    }>;
+    removeCoupon: Mut<{
+        code: string;
+    }>;
+    setShippingAddress: Mut<CartAddress>;
+    setBillingAddress: Mut<CartAddress>;
+}
+/**
+ * Cart write operations with optimistic cache updates and rollback.
+ *
+ * `cartId` is optional — when omitted, `storage.getCartId()` is resolved at
+ * **mutate-time** (inside `mutationFn`/`onMutate`), so post-mount writes from
+ * `useActiveCart({ create: true })` work without a render race. Throws
+ * `EmporixError("useCartMutations: no cartId available — …")` when storage
+ * is still empty at mutate-time.
+ */
+declare function useCartMutations(cartId?: string): CartMutationsApi;
+/**
+ * Creates a cart. Auto-detects auth (customer if a token is stored, else
+ * anonymous). On success, persists `cartId` via `storage.setCartId` so a later
+ * page reload can resume the same cart with the same anonymous session, then
+ * invalidates `["emporix","cart"]` so `useActiveCart` re-reads storage on the
+ * next render.
+ *
+ * Note: the SDK's `carts.create` returns `CartCreated = { cartId, yrn }`, not
+ * the full `Cart`. The full cart is loaded on demand by `useCart(cartId)` /
+ * `useActiveCart()`.
+ */
+declare function useCreateCart(): UseMutationResult<CartCreated, unknown, CreateCartInput | undefined>;
+/**
+ * Resolves to "the active cart": the cart matching `storage.cartId` if one is
+ * present. With `create: true`, bootstraps a new cart via
+ * `client.carts.getCurrent({siteCode, create: true})` when storage is empty —
+ * useful on cart-page mounts where you want a cart unconditionally.
+ *
+ * Internally delegates to `useCart` so both hooks share the canonical
+ * `["emporix","cart", id, …]` cache entry — optimistic updates from
+ * `useCartMutations` propagate automatically.
+ *
+ * Returns `UseQueryResult<Cart | null>`. `data: null` means "no cart yet and
+ * create was not requested" — a deliberate signal so an empty-state can
+ * render without confusing it with the loading state.
+ */
+declare function useActiveCart(opts?: {
+    create?: boolean;
+    type?: string;
+    legalEntityId?: string;
+    auth?: AuthContext;
+}): UseQueryResult<Cart | null>;
+
+/** Checkout actions bound to the stored customer session. */
+interface CheckoutApi {
+    placeOrder: UseMutationResult<CheckoutResult, unknown, {
+        input: CheckoutInput;
+        saasToken?: string;
+        siteCode?: string;
+    }>;
+    placeOrderFromQuote: UseMutationResult<CheckoutResult, unknown, {
+        input: QuoteCheckoutInput;
+        saasToken?: string;
+        siteCode?: string;
+    }>;
+}
+/** React bindings for the checkout flow. */
+declare function useCheckout(): CheckoutApi;
+/** Lists frontend payment modes for the logged-in customer. */
+declare function usePaymentModes(options?: {
+    enabled?: boolean;
+}): UseQueryResult<PaymentMode[]>;
+
+/**
+ * Resolves prices for `input.items` via `prices.matchByContext`. Defaults to
+ * the anonymous session token (context bound at anonymous-login); pass a
+ * customer token for personalized pricing. The SDK does not cache prices —
+ * control freshness via the query key / `enabled` (re-run before checkout).
+ */
+declare function useMatchPrices(input: PriceMatchByContextInput, options?: {
+    enabled?: boolean;
+    customerToken?: string | null;
+}): UseQueryResult<PriceMatch[]>;
+
+/**
+ * Reads `productMedia` from the existing product query — no Media-Service
+ * call (those need a server-only scope). For admin/server flows, use
+ * `client.media.listForProduct(productId)` instead.
+ */
+declare function useProductMedia(productId: string): {
+    data: Media[] | undefined;
+    isLoading: boolean;
+    error: unknown;
+};
+
+/** Segments the logged-in customer belongs to (`segment_read_own`). */
+declare function useMySegments(query?: {
+    q?: string;
+    pageNumber?: number;
+    pageSize?: number;
+}): UseQueryResult<Segment[]>;
+/** Item assignments (PRODUCT + CATEGORY) across the caller's active segments. */
+declare function useMySegmentItems(query?: {
+    q?: string;
+    siteCode?: string;
+    legalEntityId?: string;
+    onlyActive?: boolean;
+}): UseQueryResult<SegmentItem[]>;
+/** Category tree filtered to the caller's segments. */
+declare function useMySegmentCategoryTree(query?: {
+    siteCode?: string;
+    legalEntityId?: string;
+}): UseQueryResult<SegmentCategoryTree>;
+/** Hydrated PRODUCT page for the caller's segments (single-page). */
+declare function useMySegmentProducts(query?: {
+    q?: string;
+    siteCode?: string;
+    legalEntityId?: string;
+    onlyActive?: boolean;
+    pageNumber?: number;
+    pageSize?: number;
+}): UseQueryResult<PaginatedItems<Product>>;
+/**
+ * Hydrated PRODUCT pages — infinite scroll. `data.pages` is an array of
+ * pages; call `fetchNextPage()` to load the next one. Terminates when
+ * the source segment-items page is not full.
+ */
+declare function useMySegmentProductsInfinite(query?: {
+    q?: string;
+    siteCode?: string;
+    legalEntityId?: string;
+    onlyActive?: boolean;
+    pageSize?: number;
+}): _tanstack_react_query.UseInfiniteQueryResult<{
+    pages: PaginatedItems<Product>[];
+    pageParams: number[];
+}>;
+/** Hydrated CATEGORY page for the caller's segments (single-page). */
+declare function useMySegmentCategories(query?: {
+    q?: string;
+    siteCode?: string;
+    legalEntityId?: string;
+    onlyActive?: boolean;
+    pageNumber?: number;
+    pageSize?: number;
+}): UseQueryResult<PaginatedItems<Category>>;
+/**
+ * Hydrated CATEGORY pages — infinite scroll. Same semantics as
+ * {@link useMySegmentProductsInfinite}.
+ */
+declare function useMySegmentCategoriesInfinite(query?: {
+    q?: string;
+    siteCode?: string;
+    legalEntityId?: string;
+    onlyActive?: boolean;
+    pageSize?: number;
+}): _tanstack_react_query.UseInfiniteQueryResult<{
+    pages: PaginatedItems<{
+        id: string;
+        parentId?: string | null;
+        localizedName: {
+            [key: string]: string;
+        };
+        localizedDescription?: {
+            [key: string]: string;
+        };
+        localizedSlug?: {
+            [key: string]: string;
+        };
+        name?: string;
+        description?: string;
+        code?: string;
+        ecn?: Array<string>;
+        validity?: {
+            from?: string;
+            to?: string;
+        };
+        position: number;
+        published: boolean;
+        supercategoriesIds?: Array<string>;
+        ownClassificationMixins?: Array<{
+            name: string;
+            schemaUrl: string;
+            required?: boolean;
+        }>;
+        classificationMixins?: Array<{
+            name: string;
+            mixinPath?: string;
+            schemaUrl: string;
+            required?: boolean;
+            sourceCategoryId?: string;
+        }>;
+        mixins?: {
+            [key: string]: unknown;
+        };
+        metadata: {
+            createdAt?: string;
+            modifiedAt?: string;
+        } & {
+            version?: number;
+        } & {
+            mixins?: {
+                [key: string]: string;
+            };
+        };
+        media: Array<{
+            id?: string;
+            url?: string;
+            contentType?: string;
+            metadata?: {
+                createdAt?: string;
+                modifiedAt?: string;
+            } & unknown;
+            customAttributes?: {
+                id?: string;
+                height?: number;
+                width?: number;
+                sizeKB?: number;
+                type?: string;
+                name?: string;
+            } & unknown;
+        }>;
+    }>[];
+    pageParams: number[];
+}>;
+
+/** Updates the logged-in customer's profile and invalidates the `me` query. */
+declare function useUpdateCustomer(): UseMutationResult<Customer, unknown, CustomerUpdateInput>;
+/**
+ * Changes the customer's password. No cache invalidation — no read query
+ * surfaces the password.
+ */
+declare function useChangePassword(): UseMutationResult<void, unknown, PasswordChangeInput>;
+
+/**
+ * Lists the logged-in customer's addresses. Disabled when no customer token
+ * is in storage (returns idle state, not an error).
+ */
+declare function useCustomerAddresses(options?: QueryOpts): UseQueryResult<Address[]>;
+/** Address CRUD mutations. Each invalidates `customer.addresses` on success. */
+interface AddressMutationsApi {
+    add: UseMutationResult<Address, unknown, AddressCreateInput>;
+    update: UseMutationResult<Address, unknown, {
+        id: string;
+        patch: AddressUpdateInput;
+    }>;
+    remove: UseMutationResult<void, unknown, {
+        id: string;
+    }>;
+}
+declare function useAddressMutations(): AddressMutationsApi;
+
+/**
+ * The 2-step anonymous password-reset flow. `request` triggers the reset
+ * email; `confirm` consumes the token + new password. Both use anonymous
+ * auth — the user is by definition locked out when running this flow.
+ */
+interface PasswordResetApi {
+    request: UseMutationResult<void, unknown, PasswordResetRequestInput>;
+    confirm: UseMutationResult<void, unknown, PasswordResetConfirmInput>;
+}
+declare function usePasswordReset(): PasswordResetApi;
+
+/** Lists active sites for the tenant. */
+declare function useSites(options?: QueryOpts): UseQueryResult<Site[]>;
+/** Convenience: the tenant's default site (the one flagged `default: true`). */
+declare function useDefaultSite(options?: QueryOpts): UseQueryResult<Site>;
+
+/**
+ * Returns the active site context: `{ siteCode, currency, targetLocation,
+ * setSite }`. In MS-2, `currency` and `targetLocation` are always `null`;
+ * they auto-populate in MS-4. `setSite(code)` is sync void in MS-2; it
+ * becomes async in MS-3 (PATCHing `/session-context/{tenant}/me/context`).
+ */
+declare function useSiteContext(): SiteContextValue;
+
+/** Lists the legal entities the calling customer is assigned to. */
+declare function useMyCompanies(): UseQueryResult<LegalEntity[]>;
+
+/** Fetches one legal entity by id. Disabled until a customer token is stored. */
+declare function useCompany(legalEntityId: string | undefined): UseQueryResult<LegalEntity>;
+
+/** Lists contact assignments for one legal entity. */
+declare function useCompanyContacts(legalEntityId: string | undefined): UseQueryResult<ContactAssignment[]>;
+
+/** Lists locations owned by one legal entity. */
+declare function useCompanyLocations(legalEntityId: string | undefined): UseQueryResult<Location[]>;
+
+/** Lists IAM customer-groups for one legal entity. */
+declare function useCompanyGroups(legalEntityId: string | undefined): UseQueryResult<IamGroup[]>;
+
+declare function useCreateCompany(): UseMutationResult<{
+    id: string;
+}, unknown, LegalEntityCreate>;
+declare function useUpdateCompany(): UseMutationResult<LegalEntity, unknown, {
+    id: string;
+    patch: LegalEntityUpdate;
+}>;
+declare function useDeleteCompany(): UseMutationResult<void, unknown, string>;
+declare function useAssignContact(): UseMutationResult<{
+    id: string;
+}, unknown, ContactAssignmentCreate>;
+declare function useUpdateContactAssignment(): UseMutationResult<ContactAssignment, unknown, {
+    id: string;
+    patch: ContactAssignmentUpdate;
+}>;
+declare function useUnassignContact(): UseMutationResult<void, unknown, string>;
+declare function useCreateLocation(): UseMutationResult<{
+    id: string;
+}, unknown, LocationCreate>;
+declare function useUpdateLocation(): UseMutationResult<Location, unknown, {
+    id: string;
+    patch: LocationUpdate;
+}>;
+declare function useDeleteLocation(): UseMutationResult<void, unknown, string>;
+
+interface CompanySwitcherApi {
+    companies: LegalEntity[];
+    active: LegalEntity | null;
+    status: "idle" | "loading" | "switching" | "error";
+    switch: (legalEntityId: string) => Promise<void>;
+    clear: () => Promise<void>;
+}
+/** UI-friendly wrapper around useActiveCompany — exposes switch/clear pair. */
+declare function useCompanySwitcher(): CompanySwitcherApi;
+
+/** Options for `useMyOrders`. Passing `legalEntityId: null` disables the active-company auto-default. */
+interface UseMyOrdersOptions {
+    pageNumber?: number;
+    pageSize?: number;
+    status?: OrderStatus;
+    /** `undefined` = default from `useActiveCompany`. `null` = no filter. */
+    legalEntityId?: string | null;
+    saasToken?: string;
+}
+/** Paginated read of the customer's own orders. Disabled without a customer token. */
+declare function useMyOrders(options?: UseMyOrdersOptions): UseQueryResult<PaginatedItems<Order>>;
+
+interface UseMyOrdersInfiniteOptions {
+    pageSize?: number;
+    status?: OrderStatus;
+    legalEntityId?: string | null;
+    saasToken?: string;
+}
+/** Infinite paginated read of customer orders. Same defaulting rules as useMyOrders. */
+declare function useMyOrdersInfinite(options?: UseMyOrdersInfiniteOptions): UseInfiniteQueryResult<{
+    pages: PaginatedItems<Order>[];
+    pageParams: number[];
+}>;
+
+interface UseOrderOptions {
+    saasToken?: string;
+}
+/** Single-order read by id. Disabled without a customer token or when orderId is undefined. */
+declare function useOrder(orderId: string | undefined, options?: UseOrderOptions): UseQueryResult<Order>;
+
+interface UseCancelOrderVars {
+    orderId: string;
+    saasToken?: string;
+}
+/** Cancels (transitions to DECLINED) a customer's order. Invalidates ["emporix","orders"] on success. */
+declare function useCancelOrder(): UseMutationResult<void, unknown, string | UseCancelOrderVars>;
+
+interface UseOrderTransitionVars {
+    orderId: string;
+    status: OrderStatus;
+    comment?: string;
+    saasToken?: string;
+}
+/** Generic status transition. Server enforces legality. Invalidates ["emporix","orders"] on success. */
+declare function useOrderTransition(): UseMutationResult<void, unknown, UseOrderTransitionVars>;
+
+interface UseReorderVars {
+    orderId: string;
+    saasToken?: string;
+}
+interface UseReorderResult {
+    added: number;
+    errors: unknown[];
+}
+/**
+ * Re-populates the active cart from a past order via a single
+ * `cart.addItemsBatch` call. Best-effort: item-level failures land in
+ * `errors[]` instead of throwing; partial-success result shape stays
+ * `{ added, errors }`.
+ *
+ * Emporix's batch endpoint caps at 200 items per request. Orders with more
+ * line-items are not supported here — extend with chunking if a real use
+ * case appears.
+ */
+declare function useReorder(): UseMutationResult<UseReorderResult, unknown, UseReorderVars>;
+
+/** Service-account read of a single sales-order. Disabled when `auth` is undefined. */
+declare function useSalesOrder(orderId: string | undefined, authCtx: AuthContext | undefined): UseQueryResult<Order>;
+
+interface UseUpdateSalesOrderVars {
+    orderId: string;
+    patch: SalesOrderPatch;
+    auth: AuthContext;
+    recalculate?: boolean;
+}
+/**
+ * Service-account update of a sales-order. Invalidates both
+ * ["emporix","salesorders",id] and ["emporix","orders",id] (the customer-view
+ * cache for the same order) on success.
+ */
+declare function useUpdateSalesOrder(): UseMutationResult<Order, unknown, UseUpdateSalesOrderVars>;
+
+export { type AddressMutationsApi, type CartMutationsApi, type CheckoutApi, type CompanySwitcherApi, type CustomerSessionApi, type PasswordResetApi, type UseCancelOrderVars, type UseMyOrdersInfiniteOptions, type UseMyOrdersOptions, type UseOrderOptions, type UseOrderTransitionVars, type UseReorderResult, type UseReorderVars, type UseUpdateSalesOrderVars, useActiveCart, useAddressMutations, useAssignContact, useCancelOrder, useCart, useCartMutations, useCategories, useCategoriesInfinite, useCategory, useCategoryTree, useChangePassword, useCheckout, useCompany, useCompanyContacts, useCompanyGroups, useCompanyLocations, useCompanySwitcher, useCreateCart, useCreateCompany, useCreateLocation, useCustomerAddresses, useCustomerSession, useDefaultSite, useDeleteCompany, useDeleteLocation, useMatchPrices, useMyCompanies, useMyOrders, useMyOrdersInfinite, useMySegmentCategories, useMySegmentCategoriesInfinite, useMySegmentCategoryTree, useMySegmentItems, useMySegmentProducts, useMySegmentProductsInfinite, useMySegments, useOrder, useOrderTransition, usePasswordReset, usePaymentModes, useProduct, useProductByCode, useProductMedia, useProductSearch, useProducts, useProductsInCategory, useProductsInCategoryInfinite, useProductsInfinite, useReorder, useSalesOrder, useSiteContext, useSites, useUnassignContact, useUpdateCompany, useUpdateContactAssignment, useUpdateCustomer, useUpdateLocation, useUpdateSalesOrder };

package/dist/hooks.js

@@ -0,0 +1,5 @@
+export { useActiveCart, useAddressMutations, useAssignContact, useCancelOrder, useCart, useCartMutations, useCategories, useCategoriesInfinite, useCategory, useCategoryTree, useChangePassword, useCheckout, useCompany, useCompanyContacts, useCompanyGroups, useCompanyLocations, useCompanySwitcher, useCreateCart, useCreateCompany, useCreateLocation, useCustomerAddresses, useCustomerSession, useDefaultSite, useDeleteCompany, useDeleteLocation, useMatchPrices, useMyCompanies, useMyOrders, useMyOrdersInfinite, useMySegmentCategories, useMySegmentCategoriesInfinite, useMySegmentCategoryTree, useMySegmentItems, useMySegmentProducts, useMySegmentProductsInfinite, useMySegments, useOrder, useOrderTransition, usePasswordReset, usePaymentModes, useProduct, useProductByCode, useProductMedia, useProductSearch, useProducts, useProductsInCategory, useProductsInCategoryInfinite, useProductsInfinite, useReorder, useSalesOrder, useSiteContext, useSites, useUnassignContact, useUpdateCompany, useUpdateContactAssignment, useUpdateCustomer, useUpdateLocation, useUpdateSalesOrder } from './chunk-N3VDSKCT.js';
+import './chunk-D43CSHK3.js';
+import './chunk-FBQY2N7S.js';
+//# sourceMappingURL=hooks.js.map
+//# sourceMappingURL=hooks.js.map

package/dist/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"hooks.js"}