@webround/commerce-react 0.3.15 → 0.4.1

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 export { useResource } from './use-resource.js';
-export type { UseResourceOptions, UseResourceResult } from './use-resource.js';
+export type { UseResourceOptions, UseResourceResult, UseResourceState } from './use-resource.js';
+export { useStoreData } from './use-store-data.js';
+export type { UseStoreDataOptions } from './use-store-data.js';
+export { useProduct, useProductReviews, useRelatedProducts } from './use-product.js';
+export type { ProductQuery } from './use-product.js';
 export { useShop } from './use-shop.js';
 export type { UseShopOptions, UseShopResult } from './use-shop.js';
 export { useShopAddress } from './use-shop-address.js';
@@ -18,6 +22,6 @@ export { useCustomerResource } from './use-customer-resource.js';
 export { useOrder, useOrders, useSubscription, useSubscriptions } from './use-orders.js';
 export { useGuestReturnSession, useReturnRequest, useReturnRequests } from './use-returns.js';
 export { useWishlist } from './use-wishlist.js';
-export type { UseWishlistResult } from './use-wishlist.js';
+export type { UseWishlistResult, WishlistActions } from './use-wishlist.js';
 export { useMyReviews, useReviewAbility } from './use-reviews.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,5 +1,7 @@
 // @webround/commerce-react: what a React component needs to use a store (React 19). The logic is `@webround/commerce`'s; this only binds it to components.
 export { useResource } from './use-resource.js';
+export { useStoreData } from './use-store-data.js';
+export { useProduct, useProductReviews, useRelatedProducts } from './use-product.js';
 export { useShop } from './use-shop.js';
 export { useShopAddress } from './use-shop-address.js';
 export { authActions, useAuth } from './use-auth.js';

package/dist/use-addresses.d.ts

@@ -7,9 +7,8 @@ export interface AddressActions {
     setDefault: AddressBook['setDefault'];
     refresh: AddressBook['refresh'];
 }
-export interface UseAddressesResult {
-    state: AddressBookState;
-    addresses: AddressBookState['addresses'];
+/** The addresses, by name, as `commerce.addresses.getState()` has them: `addresses`, `owner`, `loaded`, `busy`, `error`; and `actions`. */
+export interface UseAddressesResult extends AddressBookState {
     actions: AddressActions;
 }
 export declare function addressActions(book: AddressBook): AddressActions;

package/dist/use-addresses.js

@@ -15,6 +15,6 @@ export function useAddresses(commerce) {
     const state = useSyncExternalStore(book.subscribe, book.getState, book.getState);
     const actions = useMemo(() => addressActions(book), [book]);
     useEffect(() => { void book.start(); }, [book]);
-    return { state, addresses: state.addresses, actions };
+    return { ...state, actions };
 }
 //# sourceMappingURL=use-addresses.js.map

package/dist/use-auth.d.ts

@@ -1,6 +1,5 @@
-import type { Auth } from '@webround/commerce';
-import type { AuthState, AuthStatus, AuthStore, Customer } from '@webround/commerce';
-import type { TwoFactorChallenge } from '@webround/commerce';
+import type { Commerce } from '@webround/commerce';
+import type { AuthState, AuthStore } from '@webround/commerce';
 /** What changes the session. A call that fails THROWS what the store said (a wrong password, a validation list in `issues`): it belongs to the form that made it. */
 export interface AuthActions {
     signup: AuthStore['signup'];
@@ -9,16 +8,14 @@ export interface AuthActions {
     cancelChallenge: AuthStore['cancelChallenge'];
     logout: AuthStore['logout'];
 }
-export interface UseAuthResult {
-    state: AuthState;
-    /** `unknown` until it is known whether a customer is kept (and on a server render: no window, nobody to take back). */
-    status: AuthStatus;
-    customer: Customer | null;
-    /** The code of the authenticator app is wanted (status `challenge`). */
-    challenge: TwoFactorChallenge | null;
+/**
+ * The session, by name, as `commerce.auth.store.getState()` has it: `status` (`unknown` until it is known whether a customer is kept, and on a server render: no window, nobody to take back), `customer`, `challenge` (the code
+ * of the authenticator app is wanted: status `challenge`), `error`; and `actions`.
+ */
+export interface UseAuthResult extends AuthState {
     actions: AuthActions;
 }
 export declare function authActions(store: AuthStore): AuthActions;
-/** `auth` is what `createAuth` made. Any number of components can use it: the customer is taken back once. */
-export declare function useAuth(auth: Pick<Auth, 'store'>): UseAuthResult;
+/** `commerce` is what `createCommerce` made (or `@webround/commerce-react/site`'s). Any number of components can use it: the customer is taken back once. */
+export declare function useAuth(commerce: Pick<Commerce, 'auth'>): UseAuthResult;
 //# sourceMappingURL=use-auth.d.ts.map

package/dist/use-auth.js

@@ -8,13 +8,13 @@ export function authActions(store) {
         logout: () => store.logout(),
     };
 }
-/** `auth` is what `createAuth` made. Any number of components can use it: the customer is taken back once. */
-export function useAuth(auth) {
-    const { store } = auth;
+/** `commerce` is what `createCommerce` made (or `@webround/commerce-react/site`'s). Any number of components can use it: the customer is taken back once. */
+export function useAuth(commerce) {
+    const { store } = commerce.auth;
     const state = useSyncExternalStore(store.subscribe, store.getState, store.getState);
     const actions = useMemo(() => authActions(store), [store]);
     // Not in render: a server render asks nothing. `restore` is one call for whoever asks while it is under way, and nothing once it is known
     useEffect(() => { void store.restore(); }, [store]);
-    return { state, status: state.status, customer: state.customer, challenge: state.challenge, actions };
+    return { ...state, actions };
 }
 //# sourceMappingURL=use-auth.js.map

package/dist/use-cart.d.ts

@@ -7,18 +7,17 @@ export interface CartActions {
     clear: CartStore['clear'];
     refresh: CartStore['refresh'];
 }
-export interface UseCartResult {
-    state: CartState;
-    /** How many items are in the cart: known before the store has priced anything. */
-    count: number;
-    /** What the store says the cart costs (null until it said); `state.isStale` when it is one change behind. */
-    priced: CartState['priced'];
+/**
+ * The cart, by name, as `commerce.cart.getState()` has it: `lines` (what the cart IS: known at once, no network), `count` (how many items: what a badge says), `cart` (the cart as the store prices it, with names, pictures and totals:
+ * `null` until the store said; `isStale` when it is one change behind), `owner`, `busy`, `error`; and `actions`.
+ */
+export interface UseCartResult extends CartState {
     actions: CartActions;
 }
 export declare function cartActions(store: CartStore): CartActions;
 /**
- * To step a quantity (a "+" button), read it from `state.lines`, not from `priced`: `lines` is what the cart is NOW (a change shows in it at once), `priced` is the store's answer, which can be one change behind
- * (`state.isStale`), so three quick clicks on a "+" that reads `priced` ask for the same quantity three times.
+ * To step a quantity (a "+" button), read it from `lines`, not from `cart`: `lines` is what the cart is NOW (a change shows in it at once), `cart` is the store's answer, which can be one change behind
+ * (`isStale`), so three quick clicks on a "+" that reads `cart` ask for the same quantity three times.
  */
 /** `commerce` is what `createCommerce` made (or `@webround/commerce-react/site`'s). Any number of components can use it: the cart starts once. A server render says `unknown` and zero items, as the first render in the browser does. */
 export declare function useCart(commerce: {

package/dist/use-cart.js

@@ -9,8 +9,8 @@ export function cartActions(store) {
     };
 }
 /**
- * To step a quantity (a "+" button), read it from `state.lines`, not from `priced`: `lines` is what the cart is NOW (a change shows in it at once), `priced` is the store's answer, which can be one change behind
- * (`state.isStale`), so three quick clicks on a "+" that reads `priced` ask for the same quantity three times.
+ * To step a quantity (a "+" button), read it from `lines`, not from `cart`: `lines` is what the cart is NOW (a change shows in it at once), `cart` is the store's answer, which can be one change behind
+ * (`isStale`), so three quick clicks on a "+" that reads `cart` ask for the same quantity three times.
  */
 /** `commerce` is what `createCommerce` made (or `@webround/commerce-react/site`'s). Any number of components can use it: the cart starts once. A server render says `unknown` and zero items, as the first render in the browser does. */
 export function useCart(commerce) {
@@ -18,6 +18,6 @@ export function useCart(commerce) {
     const state = useSyncExternalStore(cart.subscribe, cart.getState, cart.getState);
     const actions = useMemo(() => cartActions(cart), [cart]);
     useEffect(() => { void cart.start(); }, [cart]);
-    return { state, count: state.count, priced: state.priced, actions };
+    return { ...state, actions };
 }
 //# sourceMappingURL=use-cart.js.map

package/dist/use-customer-resource.d.ts

@@ -1,5 +1,5 @@
 import type { Auth } from '@webround/commerce';
 import type { Resource } from '@webround/commerce';
 import { type UseResourceOptions, type UseResourceResult } from './use-resource.js';
-export declare function useCustomerResource<T>(auth: Pick<Auth, 'store'>, make: () => Resource<T> | null, options?: UseResourceOptions): UseResourceResult<T>;
+export declare function useCustomerResource<T extends object>(auth: Pick<Auth, 'store'>, make: () => Resource<T> | null, options?: UseResourceOptions): UseResourceResult<T>;
 //# sourceMappingURL=use-customer-resource.d.ts.map

package/dist/use-orders.d.ts

@@ -1,14 +1,14 @@
 import type { Auth } from '@webround/commerce';
 import type { Orders } from '@webround/commerce';
-import type { Order, OrderPage, PageQuery, Subscription, SubscriptionPage } from '@webround/commerce';
+import type { OrderAnswer, OrderPage, PageQuery, SubscriptionAnswer, SubscriptionPage } from '@webround/commerce';
 import type { UseResourceOptions, UseResourceResult } from './use-resource.js';
 type Source = {
     auth: Pick<Auth, 'store'>;
     orders: Orders;
 };
 export declare const useOrders: (commerce: Source, query?: PageQuery, options?: UseResourceOptions) => UseResourceResult<OrderPage>;
-export declare const useOrder: (commerce: Source, id: string | null | undefined) => UseResourceResult<Order>;
+export declare const useOrder: (commerce: Source, id: string | null | undefined) => UseResourceResult<OrderAnswer>;
 export declare const useSubscriptions: (commerce: Source, query?: PageQuery, options?: UseResourceOptions) => UseResourceResult<SubscriptionPage>;
-export declare const useSubscription: (commerce: Source, id: string | null | undefined) => UseResourceResult<Subscription>;
+export declare const useSubscription: (commerce: Source, id: string | null | undefined) => UseResourceResult<SubscriptionAnswer>;
 export {};
 //# sourceMappingURL=use-orders.d.ts.map

package/dist/use-orders.js

@@ -1,6 +1,6 @@
 import { useCustomerResource } from './use-customer-resource.js';
-export const useOrders = (commerce, query, options = { keepPrevious: true }) => useCustomerResource(commerce.auth, () => commerce.orders.list(query), options);
-export const useOrder = (commerce, id) => useCustomerResource(commerce.auth, () => (id ? commerce.orders.get(id) : null));
-export const useSubscriptions = (commerce, query, options = { keepPrevious: true }) => useCustomerResource(commerce.auth, () => commerce.orders.subscriptions.list(query), options);
-export const useSubscription = (commerce, id) => useCustomerResource(commerce.auth, () => (id ? commerce.orders.subscriptions.get(id) : null));
+export const useOrders = (commerce, query, options = { keepPrevious: true }) => useCustomerResource(commerce.auth, () => commerce.orders.resource.list(query), options);
+export const useOrder = (commerce, id) => useCustomerResource(commerce.auth, () => (id ? commerce.orders.resource.get(id) : null));
+export const useSubscriptions = (commerce, query, options = { keepPrevious: true }) => useCustomerResource(commerce.auth, () => commerce.orders.resource.subscriptions.list(query), options);
+export const useSubscription = (commerce, id) => useCustomerResource(commerce.auth, () => (id ? commerce.orders.resource.subscriptions.get(id) : null));
 //# sourceMappingURL=use-orders.js.map

package/dist/use-product.d.ts

@@ -0,0 +1,16 @@
+import type { Commerce, ProductAnswer, ProductByIdInput, ProductBySlugInput, ProductPage, ProductRelatedInput, ProductReviewsInput, ReviewPage } from '@webround/commerce';
+import { type UseResourceOptions, type UseResourceResult } from './use-resource.js';
+type Source = Pick<Commerce, 'catalog'>;
+/** The product that has the variant `slug` (a product has no slug: it is the VARIANT's), or the one with this `id`; what is loaded with it is for `include*` to say. */
+export type ProductQuery = ({
+    slug: string;
+} & ProductBySlugInput) | ({
+    id: string;
+} & ProductByIdInput);
+export declare function useProduct(commerce: Source, query: ProductQuery | null | undefined): UseResourceResult<ProductAnswer>;
+/** The reviews of a product, a page of them, with how many there are for each grade. `productId` is the product's (`product.id`). A page keeps showing the one before while the next comes. */
+export declare function useProductReviews(commerce: Source, productId: string | null | undefined, input?: ProductReviewsInput, options?: UseResourceOptions): UseResourceResult<ReviewPage>;
+/** The products related to a product (up to ten, the most relevant first). */
+export declare function useRelatedProducts(commerce: Source, productId: string | null | undefined, input: ProductRelatedInput): UseResourceResult<ProductPage>;
+export {};
+//# sourceMappingURL=use-product.d.ts.map

package/dist/use-product.js

@@ -0,0 +1,16 @@
+import { useResource } from './use-resource.js';
+export function useProduct(commerce, query) {
+    const { products } = commerce.catalog.resource;
+    return useResource(query ? ('slug' in query ? products.getBySlug(query.slug, withoutSlug(query)) : products.getById(query.id, withoutId(query))) : null);
+}
+const withoutSlug = ({ slug: _slug, ...input }) => input;
+const withoutId = ({ id: _id, ...input }) => input;
+/** The reviews of a product, a page of them, with how many there are for each grade. `productId` is the product's (`product.id`). A page keeps showing the one before while the next comes. */
+export function useProductReviews(commerce, productId, input, options = { keepPrevious: true }) {
+    return useResource(productId ? commerce.catalog.resource.products.getReviews(productId, input) : null, options);
+}
+/** The products related to a product (up to ten, the most relevant first). */
+export function useRelatedProducts(commerce, productId, input) {
+    return useResource(productId ? commerce.catalog.resource.products.getRelated(productId, input) : null);
+}
+//# sourceMappingURL=use-product.js.map

package/dist/use-resource.d.ts

@@ -1,25 +1,29 @@
 import type { Resource } from '@webround/commerce';
 export interface UseResourceOptions {
     /**
-     * When the question changes (another page of the results, another search), keep showing the answer of the one before until the new one comes, instead of nothing: `data` is that
-     * answer and `isStale` says it is not the one asked for. Off by default: what is shown is always the answer to what is asked.
+     * When the question changes (another page of the results, another search), keep showing the answer of the one before until the new one comes, instead of nothing: the keys of the answer are that
+     * answer's and `isStale` says it is not the one asked for. Off by default: what is shown is always the answer to what is asked.
      */
     keepPrevious?: boolean;
 }
-export interface UseResourceResult<T> {
+/** How the asking stands: the same fields in every hook that reads from the backend. */
+export interface UseResourceState {
     /** `idle`: nothing is asked (no resource was given). `pending`: the answer is being waited for. `ready`: it is there. `error`: it could not be had. */
     status: 'idle' | 'pending' | 'ready' | 'error';
-    /** The answer to what is asked, or (with `keepPrevious`, while the new one is awaited) the answer to the question before; undefined when there is none. */
-    data: T | undefined;
     /** Why it failed (a `CommerceError` for what the store did, or a network error): set with `status: 'error'`, undefined otherwise. */
     error: unknown;
     /** The answer to what is asked is being waited for. */
     isFetching: boolean;
-    /** `data` is the answer to an earlier question (`keepPrevious`), not to the one asked now. */
+    /** The keys of the answer are the answer to an earlier question (`keepPrevious`), not to the one asked now. */
     isStale: boolean;
     /** Asks again after an error. It does nothing in any other state: what is there is not asked for again (to forget it, invalidate it in the catalog). */
     retry: () => void;
 }
+/**
+ * What a hook gives: the keys of the answer, each by its own name (`products` and `pagination`; `order`; `reviews`, `pagination` and `breakdown`…: the same a call gives without React), `undefined` until the answer
+ * is there, together with how the asking stands (`UseResourceState`). The answer's keys never meet the state's own (`status`, `error`…): the state's are written last, and a test keeps an answer from taking one.
+ */
+export type UseResourceResult<T extends object> = Partial<T> & UseResourceState;
 /** A resource asked for by a component: `null`/`undefined` is "not asked yet" (a slug that is not known, a search that is not made). */
-export declare function useResource<T>(resource: Resource<T> | null | undefined, options?: UseResourceOptions): UseResourceResult<T>;
+export declare function useResource<T extends object>(resource: Resource<T> | null | undefined, options?: UseResourceOptions): UseResourceResult<T>;
 //# sourceMappingURL=use-resource.d.ts.map

package/dist/use-resource.js

@@ -47,14 +47,16 @@ export function useResource(resource, options = {}) {
             hasShown.current = true;
         }
     }, [snapshot]);
+    // The answer's keys first, the state's after: the state's own names win
+    const result = (state, answer) => ({ ...answer, ...state, retry });
     if (!asked)
-        return { status: 'idle', data: undefined, error: undefined, isFetching: false, isStale: false, retry };
+        return result({ status: 'idle', error: undefined, isFetching: false, isStale: false }, undefined);
     if (snapshot.status === 'ready')
-        return { status: 'ready', data: snapshot.data, error: undefined, isFetching: false, isStale: false, retry };
+        return result({ status: 'ready', error: undefined, isFetching: false, isStale: false }, snapshot.data);
     if (snapshot.status === 'error')
-        return { status: 'error', data: undefined, error: snapshot.error, isFetching: false, isStale: false, retry };
+        return result({ status: 'error', error: snapshot.error, isFetching: false, isStale: false }, undefined);
     // `idle` here is a question that is about to be asked (the effect has not run yet): it is awaited, there is no frame in which it is "nothing"
     const stale = keepPrevious && hasShown.current;
-    return { status: 'pending', data: stale ? shown.current : undefined, error: undefined, isFetching: true, isStale: stale, retry };
+    return result({ status: 'pending', error: undefined, isFetching: true, isStale: stale }, stale ? shown.current : undefined);
 }
 //# sourceMappingURL=use-resource.js.map

package/dist/use-returns.d.ts

@@ -1,14 +1,12 @@
-import type { Auth } from '@webround/commerce';
-import type { Returns } from '@webround/commerce';
-import type { GuestReturnSession, PageQuery, ReturnRequest, ReturnRequestPage } from '@webround/commerce';
+import type { Auth, GuestReturnSessionAnswer, PageQuery, ReturnRequestAnswer, ReturnRequestPage, Returns } from '@webround/commerce';
 import { type UseResourceOptions, type UseResourceResult } from './use-resource.js';
 type Source = {
     auth: Pick<Auth, 'store'>;
     returns: Returns;
 };
 export declare const useReturnRequests: (commerce: Source, query?: PageQuery, options?: UseResourceOptions) => UseResourceResult<ReturnRequestPage>;
-export declare const useReturnRequest: (commerce: Source, id: string | null | undefined) => UseResourceResult<ReturnRequest>;
+export declare const useReturnRequest: (commerce: Source, id: string | null | undefined) => UseResourceResult<ReturnRequestAnswer>;
 /** The order a guest's link opens (the `token` of the page's address; none yet is no question). */
-export declare const useGuestReturnSession: (commerce: Pick<Source, "returns">, token: string | null | undefined) => UseResourceResult<GuestReturnSession>;
+export declare const useGuestReturnSession: (commerce: Pick<Source, "returns">, token: string | null | undefined) => UseResourceResult<GuestReturnSessionAnswer>;
 export {};
 //# sourceMappingURL=use-returns.d.ts.map

package/dist/use-returns.js

@@ -1,7 +1,7 @@
-import { useCustomerResource } from './use-customer-resource.js';
 import { useResource } from './use-resource.js';
-export const useReturnRequests = (commerce, query, options = { keepPrevious: true }) => useCustomerResource(commerce.auth, () => commerce.returns.list(query), options);
-export const useReturnRequest = (commerce, id) => useCustomerResource(commerce.auth, () => (id ? commerce.returns.get(id) : null));
+import { useCustomerResource } from './use-customer-resource.js';
+export const useReturnRequests = (commerce, query, options = { keepPrevious: true }) => useCustomerResource(commerce.auth, () => commerce.returns.resource.list(query), options);
+export const useReturnRequest = (commerce, id) => useCustomerResource(commerce.auth, () => (id ? commerce.returns.resource.get(id) : null));
 /** The order a guest's link opens (the `token` of the page's address; none yet is no question). */
-export const useGuestReturnSession = (commerce, token) => useResource(token ? commerce.returns.guest.session(token) : null);
+export const useGuestReturnSession = (commerce, token) => useResource(token ? commerce.returns.resource.guest.session(token) : null);
 //# sourceMappingURL=use-returns.js.map

package/dist/use-reviews.js

@@ -1,7 +1,7 @@
 import { useSyncExternalStore } from 'react';
 import { reviewAbility } from '@webround/commerce';
 import { useCustomerResource } from './use-customer-resource.js';
-export const useMyReviews = (commerce, query, options = { keepPrevious: true }) => useCustomerResource(commerce.auth, () => commerce.reviews.mine(query), options);
+export const useMyReviews = (commerce, query, options = { keepPrevious: true }) => useCustomerResource(commerce.auth, () => commerce.reviews.resource.list(query), options);
 /** Who can write a review now: a guest has to log in, a customer whose address is not verified has to verify it, one whose is can. It follows the session. */
 export function useReviewAbility(commerce) {
     const state = useSyncExternalStore(commerce.auth.store.subscribe, commerce.auth.store.getState, commerce.auth.store.getState);

package/dist/use-shop.d.ts

@@ -1,12 +1,10 @@
-import type { CachedCatalog } from '@webround/commerce';
-import type { ProductPage, ProductSearch, StoreDataResponse } from '@webround/commerce';
+import type { Commerce, ProductPage, ProductSearch, StoreData } from '@webround/commerce';
 import { type SortOption } from '@webround/commerce';
 import type { ShopState } from '@webround/commerce';
 import { type ShopActions, type ShopStore } from '@webround/commerce';
 import type { SearchContext } from '@webround/commerce';
-import { type UseResourceResult } from './use-resource.js';
+import { type UseResourceState } from './use-resource.js';
 export interface UseShopOptions {
-    catalog: CachedCatalog;
     /** What the question needs besides what the customer chose: the currency, the language, the cadence, what the products are loaded with. */
     context: SearchContext;
     /** The state the shop starts in (only when the hook keeps the state itself: it is not read again). */
@@ -16,19 +14,19 @@ export interface UseShopOptions {
     /** While a new question is awaited, keep showing the answer to the one before (marked `isStale`), so a listing does not empty at every click. On by default. */
     keepPrevious?: boolean;
 }
-export interface UseShopResult {
-    /** What the customer chose. */
+/**
+ * The store's data (`store`, `collections`, `tags`, `attributes`, `filters`: `undefined` until it is there), the products and their `pagination` (the same: `undefined` until they are), and how the asking of the PRODUCTS
+ * stands (`status` and the rest say `pending` or `error` while the store's data, which the question needs, is awaited or failed).
+ */
+export interface UseShopResult extends Partial<StoreData>, Partial<ProductPage>, UseResourceState {
+    /** What the customer chose: the collection, the text, the tag values and ranges, the order, the page. */
     state: ShopState;
-    /** What changes it. */
+    /** What changes it. Every change that is not `setPage` goes back to page 1. */
     actions: ShopActions;
-    /** The store's own data (its tags, collections, filters, currencies): what the controls are drawn from. */
-    storeData: UseResourceResult<StoreDataResponse>;
     /** The orders that can be offered now (with the store's data in hand, and a text or not); none until it is. */
     sortOptions: SortOption[];
-    /** The question the catalog is being asked now, or null while the store's data is awaited. */
+    /** The exact question the catalog is being asked now (`state` made a request, with `context`), or `null` while the store's data is awaited. `products` are its answer. */
     question: ProductSearch | null;
-    /** The products. While the store's data is awaited this is `pending` (or its error, with a `retry` that asks for the store again). */
-    results: UseResourceResult<ProductPage>;
 }
-export declare function useShop(options: UseShopOptions): UseShopResult;
+export declare function useShop(commerce: Pick<Commerce, 'catalog'>, options: UseShopOptions): UseShopResult;
 //# sourceMappingURL=use-shop.d.ts.map

package/dist/use-shop.js

@@ -4,8 +4,10 @@ import { shopQuestion } from '@webround/commerce';
 import { sortOptionsOf } from '@webround/commerce';
 import { createShopStore, shopActions } from '@webround/commerce';
 import { useResource } from './use-resource.js';
-export function useShop(options) {
-    const { catalog, context, keepPrevious = true } = options;
+import { useStoreData } from './use-store-data.js';
+export function useShop(commerce, options) {
+    const { context, keepPrevious = true } = options;
+    const { catalog } = commerce;
     // The state: in memory, in the hook, unless a store was given
     const own = useRef(null);
     if (!options.store && !own.current)
@@ -13,19 +15,20 @@ export function useShop(options) {
     const store = options.store ?? own.current;
     const state = useSyncExternalStore(store.subscribe, store.getState, store.getState);
     const actions = useMemo(() => shopActions(store), [store]);
-    const storeData = useResource(catalog.resource.storeData.get(context.langCode === undefined ? undefined : { langCode: context.langCode }));
-    const data = storeData.data?.data;
+    const storeData = useStoreData(commerce, { langCode: context.langCode });
+    const { status: storeStatus, error: storeError, retry: retryStore, isFetching: _fetching, isStale: _stale, ...data } = storeData;
+    const { tags, attributes, collections, filters } = data;
     // A new `context` object at every render is the same context: only what is in it makes a new question
     const contextKey = canonicalJson(context);
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    const asked = useMemo(() => shopQuestion(catalog, data, state, context), [catalog, data, state, contextKey]);
+    const asked = useMemo(() => (tags && attributes && collections && filters ? shopQuestion(catalog, { tags, attributes, collections, filters }, state, context) : null), [catalog, tags, attributes, collections, filters, state, contextKey]);
     const products = useResource(asked?.resource ?? null, { keepPrevious });
-    const sortOptions = useMemo(() => (data ? sortOptionsOf(data) : []), [data]);
+    const sortOptions = useMemo(() => (tags && attributes ? sortOptionsOf({ tags, attributes }) : []), [tags, attributes]);
     // With no question yet the products are waiting for the store's data (or failed with it): say that, so the screen has one thing to look at
-    const retry = useCallback(() => storeData.retry(), [storeData]);
-    const results = asked
+    const retry = useCallback(() => retryStore(), [retryStore]);
+    const listing = asked
         ? products
-        : { status: storeData.status === 'error' ? 'error' : 'pending', data: undefined, error: storeData.error, isFetching: storeData.status !== 'error', isStale: false, retry };
-    return { state, actions, storeData, sortOptions, question: asked?.question ?? null, results };
+        : { status: storeStatus === 'error' ? 'error' : 'pending', error: storeError, isFetching: storeStatus !== 'error', isStale: false, retry };
+    return { ...data, state, actions, sortOptions, question: asked?.question ?? null, ...listing };
 }
 //# sourceMappingURL=use-shop.js.map

package/dist/use-store-data.d.ts

@@ -0,0 +1,8 @@
+import type { Commerce, StoreData } from '@webround/commerce';
+import { type UseResourceResult } from './use-resource.js';
+export interface UseStoreDataOptions {
+    /** The language the names are asked in (left out: the store's own). */
+    langCode?: string;
+}
+export declare function useStoreData(commerce: Pick<Commerce, 'catalog'>, options?: UseStoreDataOptions): UseResourceResult<StoreData>;
+//# sourceMappingURL=use-store-data.d.ts.map

package/dist/use-store-data.js

@@ -0,0 +1,6 @@
+import { useResource } from './use-resource.js';
+export function useStoreData(commerce, options = {}) {
+    const { langCode } = options;
+    return useResource(commerce.catalog.resource.storeData.get(langCode === undefined ? undefined : { langCode }));
+}
+//# sourceMappingURL=use-store-data.js.map

package/dist/use-wishlist.d.ts

@@ -1,13 +1,18 @@
 import { type Wishlist, type WishlistState } from '@webround/commerce';
-export interface UseWishlistResult {
-    state: WishlistState;
-    count: number;
-    /** Whether a variant is in the wishlist. */
-    has(variantId: string): boolean;
-    /** The switch: adds a variant that is not in the wishlist, removes one that is. Throws what the store refuses; `LOGIN_REQUIRED` for a guest. */
+export interface WishlistActions {
+    /** The switch: adds a variant that is not in the wishlist, removes one that is. Throws what the store refuses; `LOGIN_REQUIRED` for a guest. What is shown goes back to what the store holds. */
     toggle: Wishlist['toggle'];
     refresh: Wishlist['refresh'];
 }
+/**
+ * The wishlist, by name, as `commerce.wishlist.getState()` has it: `wishlist` (the items), `count`, `variantIds`, `loaded`, `enabled` (`false` once the store said it has the wishlist off), `owner`, `busy`, `error`; `has`
+ * (whether a variant is in it, for a heart); and `actions`.
+ */
+export interface UseWishlistResult extends WishlistState {
+    /** Whether a variant is in the wishlist. */
+    has(variantId: string): boolean;
+    actions: WishlistActions;
+}
 /** `commerce` is what `createCommerce` made (or `@webround/commerce-react/site`'s). Any number of components can use it (a heart on each product): the wishlist starts once. A server render says `unknown` and nothing in it. */
 export declare function useWishlist(commerce: {
     wishlist: Wishlist;

package/dist/use-wishlist.js

@@ -7,6 +7,6 @@ export function useWishlist(commerce) {
     useEffect(() => { void wishlist.start(); }, [wishlist]);
     const has = useCallback((variantId) => isInWishlist(state, variantId), [state.variantIds]);
     const actions = useMemo(() => ({ toggle: (variantId) => wishlist.toggle(variantId), refresh: () => wishlist.refresh() }), [wishlist]);
-    return { state, count: state.count, has, toggle: actions.toggle, refresh: actions.refresh };
+    return { ...state, has, actions };
 }
 //# sourceMappingURL=use-wishlist.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webround/commerce-react",
-    "version": "0.3.15",
+    "version": "0.4.1",
     "type": "module",
     "main": "./dist/index.js",
     "module": "./dist/index.js",
@@ -28,8 +28,8 @@
         "typecheck": "tsc --noEmit -p tsconfig.test.json"
     },
     "peerDependencies": {
-        "@webround/commerce": "^0.3.0",
-        "@webround/core": "^0.3.0",
+        "@webround/commerce": "^0.4.0",
+        "@webround/core": "^0.4.0",
         "react": ">=19"
     },
     "devDependencies": {