@webround/commerce 0.2.0 → 0.3.1

package/README.md

@@ -1,7 +1,7 @@
 # @webround/commerce
 
 The logic of a Webround Commerce store (catalog, customers, cart and checkout), with no UI and no framework. A site is code (tsx) that uses it; what a
-framework needs comes as an **adapter** under a sub-path of this package (`@webround/commerce/react`; `/next` and others later), never in the core.
+framework needs comes as an **adapter**, a package of its own (`@webround/commerce-react`; `@webround/commerce-next` and others later), never in the core.
 
 - It knows nothing of `@webround/core` or `@webround/editor`, and they know nothing of it. The editor edits the site's code as it always does.
 - It is a plain npm package (for now a tarball in `webround-dev-container/vendor/`, see the Makefile: `make build-commerce`, `pack`, `publish-commerce`).
@@ -55,7 +55,7 @@ Two-factor is covered when the store's key service is there (setup, confirm →
 JavaScript never sees; `credentials: 'include'`) and two cookies the CLIENT writes (so a server render can read them): `wrCsrfToken_<storeId>` (the CSRF token the login gave, 30 days, as long as the
 refresh token; a refresh sends it IN A HEADER, `x-wr-csrf`) and `wrDeviceId_<storeId>` (a year). Cookies go through a port of two functions (`browserCookiePort`, `memoryCookiePort`). `AuthStore`
 (`getState`, `subscribe` like the shop's, `restore`, `signup`, `login`, `verifyTwoFactor`, `logout`, `refresh`, `accessToken`, `authHeaders`): `unknown` → `signedOut` | `signedIn`; a login may be a `challenge`
-(two-factor). It renews the JWT a minute before it ends (a timer) and before it is used; a renewal that could not reach the store is asked again after 2, 4, 8, 16 and 30 seconds, for as long as the JWT is good (a page that loaded with no network: ten asks); a `WakePort` (`browserWakePort`: tab visible again, `online`, `pageshow`) makes it look at the JWT against the clock when the page is back, since a timer does not run while a machine sleeps; `dispose()` stops the timer and the port; **The cart's calls** (`src/cart/`, `createCartApi(http)`; step 1 of the cart): `get`, `addItem`, `updateItem`, `removeItem`, `merge` (these need the JWT: pass the client of `createAuth`), `total` and `verifyPromotions` (with or without one: a guest's lines are in the page and `total` prices them). What the real store does, found by `smoke:cart` and written in the types: `addItem` ADDS to a variant that is already there and answers what happened, not the cart (ask with `get`); a cart has 99 different variants at most and ONE currency and cadence (`CART_LIMIT_REACHED`, `CART_CURRENCY_MISMATCH`, in `CART_ERROR_CODES`); the two totals count only the lines that are AVAILABLE (`isAvailable`); `total` leaves out a variant the store does not have (it does not refuse it) and gives a guest's lines no `id`; `verifyPromotions` with no codes, or with one the store does not know, is 404 `PROMOTION_INVALID`, and wants `cartTotal` as a text of digits; an option of a line is `{ optionName, tagValue, tagValueAlias }` in what `total` answers (the value in the language asked) and `{ optionName, optionValue }` in a customer's cart (the value as it was saved: another thing, not another name). Next: the cart's store (a guest's lines in `localStorage`, the customer's cart, `merge` at login, following `useAuth`), then `useCart`. **The cart's store** (`src/cart/store.ts`, `commerce.cart`; `useCart(commerce)` in `/react`): not logged in, the cart is a guest's: lines kept in the browser (`CartStorage` over a `KeyValuePort`, `localStorage` by default, memory where there is none; key `wrCart_<storeId>`) and priced by the store's `total`. Logged in, it is the customer's and every action is a call of the store's. When a customer logs in or signs up with lines in the browser they are merged with the store's `merge`, and forgotten ONLY once the store has them (a merge that could not be asked for loses nothing and is asked again at the next read; one the store refuses for the lines, 400/404/409/422, is not asked again until the next login; a 403 is asked again: the store answers it right after a signup). State: `lines`/`count` (what the cart IS: known at once) apart from `priced`/`isStale` (what it COSTS: the store's answer, which may be one change behind). Actions (`add`, `setQuantity`, `remove`, `refresh`) go one at a time; a customer's shows at once and is settled with one read when the last is done; a refused one THROWS what the store said and the cart goes back to what the store holds. The cart's `cartTrackingId` (the store's analytics id) is made the first time it is needed, sent with every read and pricing, kept from the guest's cart to the customer's after logging in, and forgotten when the cart is empty. Logging out gives the browser's cart back (empty if its lines were merged): the customer's does not come along. To step a quantity read it from `state.lines`, not from `priced`. A server render says `unknown` and zero items, as the first render in the browser does. **The account** (`src/account/`, `commerce.account`; `useAccount(commerce)` in `/react`): the requests a customer makes about their own account, each one call of the store's. `requestPasswordReset(email)`, `resendVerification()`, `requestAccountDeletion()` only ASK: the store sends an email and the page it leads to (where a password is chosen, an address is verified, a deletion is confirmed) is the store's own. `startTwoFactorSetup()` gives the secret and the address an authenticator app takes; `confirmTwoFactor(code)` turns it on, takes the new session (the customer is `twoFactorEnabled`) and gives the RECOVERY CODES, once (turning it off does not exist in the store). The newsletter is a strategy the store applies and `newsletterStrategy(authState)` tells the screen: a logged-in customer with a verified address is done AT ONCE with their own address (`direct: true`; the session is then read again so `customer.newsletter` says it); a customer whose address is not verified, or a guest (who has to say which address), gets an email with a link (`direct: false`). Asked by someone who is NOT logged in with a REGISTERED address (the store does not look at whether it is verified, for a guest): subscribing sends the owner an email and changes nothing (`direct: false`), unless the address is already subscribed, which it answers `direct: true` (so a guest can learn that an address is subscribed); cancelling sends an email only if it is subscribed, and answers `direct: false` either way. The store limits subscribing and cancelling to 5 a day each per IP. A signup's `newsletter: true` is applied only when the address is verified. Seen on the real store: a logged-in customer already subscribed gets `direct: false` and no email; a guest cancelling an address that was never confirmed gets `direct: false` (an email); a customer cancelling when not subscribed gets `direct: true`. **The addresses** (`src/addresses/`, `commerce.addresses`; `useAddresses(commerce)` in `/react`): a CUSTOMER's addresses are the store's (`/store-customers-addresses`): every action is a call of its and what is shown is what the store holds afterwards (making one the default takes it from the one that was). A GUEST's addresses are kept NOWHERE: in memory, for as long as the page lives (a checkout needs one to ship to and one to bill), with an id of their own (`local-…`); they do not go to a customer when somebody logs in, nor a customer's to a guest. `remember(input)` is what a checkout calls with an address just entered: it keeps it if the customer does not have it already (the same address whatever case and spacing; being a default does not make it another) and gives back the one that is kept. A store keeps 5 addresses for a customer by default (it depends on the plan); the one that goes over is answered with a **429 and no code** ("Too many store_customer_addresss. Limit is 5."), like a rate limit: `dataLimitOf(error)` tells it apart (from the message) and says the limit. **What the customer bought** (`src/orders/`, `commerce.orders`; `useOrders`, `useOrder`, `useSubscriptions`, `useSubscription` in `/react`): the customer's orders, one order and their subscriptions, a page at a time (`page`, `limit` 1 to 100 and 25 by default, `sortBy`, `sortDirection`, `lang`), as RESOURCES of the same cache the catalog is in (`useResource` shows them; a page keeps showing the one before while the next comes). They are the customer's own: the key says whose, there is no resource (`idle` in a hook) when nobody is logged in, and when the customer goes (a logout, another login) what was kept for them is forgotten (`createCustomerResources`, which is what the returns, the reviews and the rest of what a customer reads will be made with). `commerce.orders.refresh()` forgets what was kept (a customer who has just bought wants to see it). An order's items carry `orderItemId`, which a return request names. Held against a real store: the pages (empty, with their pagination), the refusals (404 for what is not the customer's, 400 for a page that is not one) and the cache; the shape of an order that is NOT empty is the types' (the store's code and documentation), to be held against a store that has orders. **Returns** (`src/returns/`, `commerce.returns`; `useReturnRequests`, `useReturnRequest`, `useGuestReturnSession` in `/react`): a CUSTOMER's requests are resources of the cache (their own, as the orders are: `list`, `get`), and `create(input)` / `cancel(id)` forget what was kept so the next read is what the store holds. The `orderItemId`s are the ones of an order's items (`commerce.orders`). Only a `pending` request can be cancelled (the store answers 400 to any other). A GUEST (someone who bought with no account) goes through a LINK: `guest.requestLink({ customerEmail, orderId | reference })` asks the store to email it to the address of the order (it answers the same whether the order exists or not; an order that belongs to an account is refused, 400: its customer logs in). **The link leads to the SITE's page `/returns?token=…`** (the store builds it from the draft's domain): the site needs that page, which reads `token` from the address and shows `useGuestReturnSession(commerce, token)` (the order and its items to choose from); `guest.create({ token, items, reason, shippingAddress, billingAddress })` and `guest.cancel(id, token)` prove who they are by the token (401 for one that is not good or has ended). Held against a real store: what it says to a customer with no orders (an empty page, 404 for an order or a request that is not theirs), to a guest asking for a link, and to a token that is not good; NOT held: a request that is made (it needs an order) and the link itself (it is emailed): their shapes are the types' (the store's code). **The wishlist** (`src/wishlist/`, `commerce.wishlist`; `useWishlist(commerce)` in `/react`): a CUSTOMER's, kept by the store (`/store-customer-wishlists`: the list and one call that is a SWITCH, adding a variant that is not in it and removing one that is). A guest has none: the switch refuses with `LOGIN_REQUIRED` (for the screen to ask them to log in) and the store is not asked. The state is what a heart needs: `variantIds` (which variants are in it, `has(variantId)` in the hook, `isInWishlist`), `count`, `enabled`. A switch shows at once and is settled with what the store holds (read again afterwards); one the store refuses throws what it said and the state goes back to what it was; switches go one at a time. A store can turn the wishlist off (403 "Wishlist is disabled for this store"): `enabled` is `false` from then and the screen can hide its hearts (nothing says it before the first ask: the store's `store_data` does not carry the flag). The store keeps 50 variants for each customer by default; the one that goes over is a 429 with no code (`dataLimitOf`). **Seen on the real store, and it is the store's to fix:** AT the limit even a removal is refused (the same 429): the rule counts the items plus one on every POST of the switch, and removing is the same POST, so a customer who has 50 can not take one out. **Reviews, written** (`src/reviews/`, `commerce.reviews`; `useMyReviews`, `useReviewAbility` in `/react`): a customer's own reviews (`mine`, a resource of the cache: theirs, none when nobody is logged in), and `create(variantId, { rating 1-5, title 2-100, comment 10-2000 })`, `update(id, patch)`, `remove(id)`: the store answers them in `data` and the facade gives that back unwrapped. The store lets only a customer whose address is VERIFIED write (`EMAIL_NOT_VERIFIED`, 400; a change asks for it too, a removal does not), one review for each variant (`REVIEW_ALREADY_EXISTS`, 409) and can turn reviews off (403). `reviewAbility(authState)` / `useReviewAbility` is the hint for the screen (`login`, `verify`, `allowed`: the store decides, the session may be one verification behind). A guest is asked to log in (`LOGIN_REQUIRED`) without asking the store. Writing, changing or removing forgets what was kept of the customer's reviews AND what the catalog kept of that product's reviews (`products.getReviews`; all of them after a removal, which does not say the product), so the next read shows it. Held against a real store: the customer's page (empty), the refusals and the store's rule; NOT held: a review that is written, changed and removed (it needs a verified address, which takes the link in the email): its shape is the types' (the store's code). **What the package does NOT check (decided 14/10).** The store is the source of truth, so the package does not validate what the store validates, and never refuses a request the store might accept: an address, a return, a review, a quantity, a page or a text that is too big or too small is SENT, and the store's 400 comes back as a `CommerceError` (`issues` lists the fields, `code` is what an interface translates). The types (`AddressInput`, `ReviewInput`, `CreateReturnInput`, `CartLineInput`…) are where a screen is told at compile time that something is not right: a type error is a warning, not a request that is not made. This keeps a version of the package working against a store whose rules moved. What stays is not validation: a guest has no wishlist or reviews (`LOGIN_REQUIRED`, the store is not asked: that will not change), `reviewAbility` and `newsletterStrategy` as hints for the screen (the store decides), the guest's cart keeps one line for each variant (adding to a variant adds), and `sameAddress` for `remember`. **`createCommerce({ storeId, commerceApiUrl, catalogApiUrl, … })`** makes what a page needs of ONE store together: `auth` (the session, over the commerce API), `catalog` (cached, over the catalog API: another address) and their `cache`; plain configuration, no environment. **`@webround/commerce/site`** is the store of THIS site, made from what it was built with (`wrSiteEnv` of `@webround/core`: `VITE_WR_DRAFT_ID`, which is the `storeId`, `VITE_WR_COMMERCE_API_URL`, `VITE_WR_CATALOG_API_URL`): `import { commerce } from '@webround/commerce/site'`, then `useAuth(commerce.auth)`. It is made the first time `commerce.auth`/`.catalog` is read, not when it is imported: a site built without the variables fails where it uses the store and says which are missing (`commerceFromEnv(env, options)` is the same with an environment you give). **`useAuth(auth)`** in `/react` (`auth` is what `createAuth` made, a module of the site makes it once and components import it; no Provider): `{ state, status, customer, challenge, actions }`, `actions` = `signup`, `login`, `verifyTwoFactor`, `cancelChallenge`, `logout` (one object, the same at every render). A call that fails THROWS what the store said: it belongs to the form that made it. The first component that mounts takes the customer back (`restore`, once); a server render says `unknown` and asks nothing; one refresh at a time; a refresh the store REFUSES (401/403) ends the session, one that cannot be reached
+(two-factor). It renews the JWT a minute before it ends (a timer) and before it is used; a renewal that could not reach the store is asked again after 2, 4, 8, 16 and 30 seconds, for as long as the JWT is good (a page that loaded with no network: ten asks); a `WakePort` (`browserWakePort`: tab visible again, `online`, `pageshow`) makes it look at the JWT against the clock when the page is back, since a timer does not run while a machine sleeps; `dispose()` stops the timer and the port; **The cart's calls** (`src/cart/`, `createCartApi(http)`; step 1 of the cart): `get`, `addItem`, `updateItem`, `removeItem`, `merge` (these need the JWT: pass the client of `createAuth`), `total` and `verifyPromotions` (with or without one: a guest's lines are in the page and `total` prices them). What the real store does, found by `smoke:cart` and written in the types: `addItem` ADDS to a variant that is already there and answers what happened, not the cart (ask with `get`); a cart has 99 different variants at most and ONE currency and cadence (`CART_LIMIT_REACHED`, `CART_CURRENCY_MISMATCH`, in `CART_ERROR_CODES`); the two totals count only the lines that are AVAILABLE (`isAvailable`); `total` leaves out a variant the store does not have (it does not refuse it) and gives a guest's lines no `id`; `verifyPromotions` with no codes, or with one the store does not know, is 404 `PROMOTION_INVALID`, and wants `cartTotal` as a text of digits; an option of a line is `{ optionName, tagValue, tagValueAlias }` in what `total` answers (the value in the language asked) and `{ optionName, optionValue }` in a customer's cart (the value as it was saved: another thing, not another name). Next: the cart's store (a guest's lines in `localStorage`, the customer's cart, `merge` at login, following `useAuth`), then `useCart`. **The cart's store** (`src/cart/store.ts`, `commerce.cart`; `useCart(commerce)` in `/react`): not logged in, the cart is a guest's: lines kept in the browser (`CartStorage` over a `KeyValuePort`, `localStorage` by default, memory where there is none; key `wrCart_<storeId>`) and priced by the store's `total`. Logged in, it is the customer's and every action is a call of the store's. When a customer logs in or signs up with lines in the browser they are merged with the store's `merge`, and forgotten ONLY once the store has them (a merge that could not be asked for loses nothing and is asked again at the next read; one the store refuses for the lines, 400/404/409/422, is not asked again until the next login; a 403 is asked again: the store answers it right after a signup). State: `lines`/`count` (what the cart IS: known at once) apart from `priced`/`isStale` (what it COSTS: the store's answer, which may be one change behind). Actions (`add`, `setQuantity`, `remove`, `refresh`) go one at a time; a customer's shows at once and is settled with one read when the last is done; a refused one THROWS what the store said and the cart goes back to what the store holds. The cart's `cartTrackingId` (the store's analytics id) is made the first time it is needed, sent with every read and pricing, kept from the guest's cart to the customer's after logging in, and forgotten when the cart is empty. Logging out gives the browser's cart back (empty if its lines were merged): the customer's does not come along. To step a quantity read it from `state.lines`, not from `priced`. A server render says `unknown` and zero items, as the first render in the browser does. **The account** (`src/account/`, `commerce.account`; `useAccount(commerce)` in `/react`): the requests a customer makes about their own account, each one call of the store's. `requestPasswordReset(email)`, `resendVerification()`, `requestAccountDeletion()` only ASK: the store sends an email and the page it leads to (where a password is chosen, an address is verified, a deletion is confirmed) is the store's own. `startTwoFactorSetup()` gives the secret and the address an authenticator app takes; `confirmTwoFactor(code)` turns it on, takes the new session (the customer is `twoFactorEnabled`) and gives the RECOVERY CODES, once (turning it off does not exist in the store). The newsletter is a strategy the store applies and `newsletterStrategy(authState)` tells the screen: a logged-in customer with a verified address is done AT ONCE with their own address (`direct: true`; the session is then read again so `customer.newsletter` says it); a customer whose address is not verified, or a guest (who has to say which address), gets an email with a link (`direct: false`). Asked by someone who is NOT logged in with a REGISTERED address (the store does not look at whether it is verified, for a guest): subscribing sends the owner an email and changes nothing (`direct: false`), unless the address is already subscribed, which it answers `direct: true` (so a guest can learn that an address is subscribed); cancelling sends an email only if it is subscribed, and answers `direct: false` either way. The store limits subscribing and cancelling to 5 a day each per IP. A signup's `newsletter: true` is applied only when the address is verified. Seen on the real store: a logged-in customer already subscribed gets `direct: false` and no email; a guest cancelling an address that was never confirmed gets `direct: false` (an email); a customer cancelling when not subscribed gets `direct: true`. **The addresses** (`src/addresses/`, `commerce.addresses`; `useAddresses(commerce)` in `/react`): a CUSTOMER's addresses are the store's (`/store-customers-addresses`): every action is a call of its and what is shown is what the store holds afterwards (making one the default takes it from the one that was). A GUEST's addresses are kept NOWHERE: in memory, for as long as the page lives (a checkout needs one to ship to and one to bill), with an id of their own (`local-…`); they do not go to a customer when somebody logs in, nor a customer's to a guest. `remember(input)` is what a checkout calls with an address just entered: it keeps it if the customer does not have it already (the same address whatever case and spacing; being a default does not make it another) and gives back the one that is kept. A store keeps 5 addresses for a customer by default (it depends on the plan); the one that goes over is answered with a **429 and no code** ("Too many store_customer_addresss. Limit is 5."), like a rate limit: `dataLimitOf(error)` tells it apart (from the message) and says the limit. **What the customer bought** (`src/orders/`, `commerce.orders`; `useOrders`, `useOrder`, `useSubscriptions`, `useSubscription` in `/react`): the customer's orders, one order and their subscriptions, a page at a time (`page`, `limit` 1 to 100 and 25 by default, `sortBy`, `sortDirection`, `lang`), as RESOURCES of the same cache the catalog is in (`useResource` shows them; a page keeps showing the one before while the next comes). They are the customer's own: the key says whose, there is no resource (`idle` in a hook) when nobody is logged in, and when the customer goes (a logout, another login) what was kept for them is forgotten (`createCustomerResources`, which is what the returns, the reviews and the rest of what a customer reads will be made with). `commerce.orders.refresh()` forgets what was kept (a customer who has just bought wants to see it). An order's items carry `orderItemId`, which a return request names. Held against a real store: the pages (empty, with their pagination), the refusals (404 for what is not the customer's, 400 for a page that is not one) and the cache; the shape of an order that is NOT empty is the types' (the store's code and documentation), to be held against a store that has orders. **Returns** (`src/returns/`, `commerce.returns`; `useReturnRequests`, `useReturnRequest`, `useGuestReturnSession` in `/react`): a CUSTOMER's requests are resources of the cache (their own, as the orders are: `list`, `get`), and `create(input)` / `cancel(id)` forget what was kept so the next read is what the store holds. The `orderItemId`s are the ones of an order's items (`commerce.orders`). Only a `pending` request can be cancelled (the store answers 400 to any other). A GUEST (someone who bought with no account) goes through a LINK: `guest.requestLink({ customerEmail, orderId | reference })` asks the store to email it to the address of the order (it answers the same whether the order exists or not; an order that belongs to an account is refused, 400: its customer logs in). **The link leads to the SITE's page `/returns?token=…`** (the store builds it from the draft's domain): the site needs that page, which reads `token` from the address and shows `useGuestReturnSession(commerce, token)` (the order and its items to choose from); `guest.create({ token, items, reason, shippingAddress, billingAddress })` and `guest.cancel(id, token)` prove who they are by the token (401 for one that is not good or has ended). Held against a real store: what it says to a customer with no orders (an empty page, 404 for an order or a request that is not theirs), to a guest asking for a link, and to a token that is not good; NOT held: a request that is made (it needs an order) and the link itself (it is emailed): their shapes are the types' (the store's code). **The wishlist** (`src/wishlist/`, `commerce.wishlist`; `useWishlist(commerce)` in `/react`): a CUSTOMER's, kept by the store (`/store-customer-wishlists`: the list and one call that is a SWITCH, adding a variant that is not in it and removing one that is). A guest has none: the switch refuses with `LOGIN_REQUIRED` (for the screen to ask them to log in) and the store is not asked. The state is what a heart needs: `variantIds` (which variants are in it, `has(variantId)` in the hook, `isInWishlist`), `count`, `enabled`. A switch shows at once and is settled with what the store holds (read again afterwards); one the store refuses throws what it said and the state goes back to what it was; switches go one at a time. A store can turn the wishlist off (403 "Wishlist is disabled for this store"): `enabled` is `false` from then and the screen can hide its hearts (nothing says it before the first ask: the store's `store_data` does not carry the flag). The store keeps 50 variants for each customer by default; the one that goes over is a 429 with no code (`dataLimitOf`). **Seen on the real store, and it is the store's to fix:** AT the limit even a removal is refused (the same 429): the rule counts the items plus one on every POST of the switch, and removing is the same POST, so a customer who has 50 can not take one out. **Reviews, written** (`src/reviews/`, `commerce.reviews`; `useMyReviews`, `useReviewAbility` in `/react`): a customer's own reviews (`mine`, a resource of the cache: theirs, none when nobody is logged in), and `create(variantId, { rating 1-5, title 2-100, comment 10-2000 })`, `update(id, patch)`, `remove(id)`: the store answers them in `data` and the facade gives that back unwrapped. The store lets only a customer whose address is VERIFIED write (`EMAIL_NOT_VERIFIED`, 400; a change asks for it too, a removal does not), one review for each variant (`REVIEW_ALREADY_EXISTS`, 409) and can turn reviews off (403). `reviewAbility(authState)` / `useReviewAbility` is the hint for the screen (`login`, `verify`, `allowed`: the store decides, the session may be one verification behind). A guest is asked to log in (`LOGIN_REQUIRED`) without asking the store. Writing, changing or removing forgets what was kept of the customer's reviews AND what the catalog kept of that product's reviews (`products.getReviews`; all of them after a removal, which does not say the product), so the next read shows it. Held against a real store: the customer's page (empty), the refusals and the store's rule; NOT held: a review that is written, changed and removed (it needs a verified address, which takes the link in the email): its shape is the types' (the store's code). **What the package does NOT check (decided 14/10).** The store is the source of truth, so the package does not validate what the store validates, and never refuses a request the store might accept: an address, a return, a review, a quantity, a page or a text that is too big or too small is SENT, and the store's 400 comes back as a `CommerceError` (`issues` lists the fields, `code` is what an interface translates). The types (`AddressInput`, `ReviewInput`, `CreateReturnInput`, `CartLineInput`…) are where a screen is told at compile time that something is not right: a type error is a warning, not a request that is not made. This keeps a version of the package working against a store whose rules moved. What stays is not validation: a guest has no wishlist or reviews (`LOGIN_REQUIRED`, the store is not asked: that will not change), `reviewAbility` and `newsletterStrategy` as hints for the screen (the store decides), the guest's cart keeps one line for each variant (adding to a variant adds), and `sameAddress` for `remember`. **`createCommerce({ storeId, commerceApiUrl, catalogApiUrl, … })`** makes what a page needs of ONE store together: `auth` (the session, over the commerce API), `catalog` (cached, over the catalog API: another address) and their `cache`; plain configuration, no environment. **`@webround/commerce-react/site`** is the store of THIS site, made from what it was built with (`wrSiteEnv` of `@webround/core`: `VITE_WR_DRAFT_ID`, which is the `storeId`, `VITE_WR_COMMERCE_API_URL`, `VITE_WR_CATALOG_API_URL`): `import { commerce } from '@webround/commerce-react/site'`, then `useAuth(commerce.auth)`. It is made the first time `commerce.auth`/`.catalog` is read, not when it is imported: a site built without the variables fails where it uses the store and says which are missing (`commerceFromEnv(env, options)` is the same with an environment you give). **`useAuth(auth)`** in `/react` (`auth` is what `createAuth` made, a module of the site makes it once and components import it; no Provider): `{ state, status, customer, challenge, actions }`, `actions` = `signup`, `login`, `verifyTwoFactor`, `cancelChallenge`, `logout` (one object, the same at every render). A call that fails THROWS what the store said: it belongs to the form that made it. The first component that mounts takes the customer back (`restore`, once); a server render says `unknown` and asks nothing; one refresh at a time; a refresh the store REFUSES (401/403) ends the session, one that cannot be reached
 does not (it keeps what is good, with `error`); a renewal that comes back after a logout does not bring the session back; logout never throws. `createAuth` makes the store with a client that carries no
 JWT (it asks for the JWT) and gives the site another that carries it. Seen against the real store: it answers a signup/login from inside its transaction, so a call made at once can be refused
 (a refresh: 401 "Invalid Token"; a call with the JWT: 403 "Customer not found"; a logout: 401 "Token mismatch"; the second step of a two-factor login: 404 "Challenge not found"): it
@@ -79,7 +79,7 @@ answer to an older question is thrown away. `isStale` says the answer on show is
 A refused preview throws what the store said, leaves it in `state.error` and keeps the last good one on show as stale. `ensureQuote()` is what a page does by itself: it asks unless the cart is empty or this very question was already asked (by anyone:
 a refusal is not asked again by itself, any number of components can call it); `useCheckout` calls it when the cart or the choices change (`autoQuote: false` turns that off). Nothing is checked here: a cart with no lines, a missing delivery or a
 code that does not exist is sent, and the store's refusal comes back. What the checkout refuses on purpose has a `code` (`CHECKOUT_ERROR_CODES`: `CHECKOUT_BLOCKED` with `{ hookId, code, target }`, `CHECKOUT_HOOK_FAILED`, `SHIPPING_METHOD_UNAVAILABLE`) and
-`checkoutRefusalOf(error)` reads it with its `meta` typed. **Lines with not enough stock** (19/10): the preview does not refuse them, it SETS THEM APART: `quote.unavailable` has them (`QuoteUnavailableLine`: priced like the others but without discounts, with `availableStock`; the whole line even if some units exist), and `quote.items` and `quote.totals` count only what can be bought. The preview is still asked WITH every line (it is what says which ones are unavailable); the payment is not: `pay()` leaves out the lines the last preview said are unavailable (and their delivery method), and when none is left it throws `NOTHING_TO_PAY` without asking the store. A page pays with a fresh preview; the store's own 400 (`Insufficient stock…`, the last unit sold between the preview and the payment) is what is left, and the page asks for the preview again. **The preview describes the lines too** (19/10): each line of `items` and of `unavailable` carries `variantName`, `productName`, `variantSlug`, `skuCode`, `coverUrl`, `options`, `allowedDeliveryMethods` (what `deliveryMethods` can choose from), `availableStock`, `allowBackorder` and `maxOrderQuantity` (`QuoteLinePresentation`): in the v2 flow it is the ONE call that prices a cart and describes it, and it replaces `/cart/total` (the store reads these from OpenSearch like `/cart/total` does). A site that works this way makes its store with `cartPricing: false` (`CartStoreOptions.pricing`; `@webround/commerce/site` does): a guest's lines are kept and counted, `priced` stays null and `/cart/total` is never asked; a customer's cart is still read with `/cart/get`, which is where its lines are. **Delivery**: the preview does not need the customer's delivery choice for every line: one without a choice gets the product's default (shipping, else pickup, else none) in the line's `deliveryMethod`, and `allowedDeliveryMethods` says what else it could be; `pay()` sends the customer's choice or, for a line they did not choose for, the one the last preview gave it. **Tracking**: the store's preview sends the cart's analytics event (`cartTrackingId`, as `/cart/total` did), so a site that never calls `/cart/total` is still tracked. **Paying**: `pay(returnUrls?)` builds the order's body from the same choices, `email` (a guest's: who the order is for) and, for an invoice, both codes (a missing one goes as an empty text for the store to
+`checkoutRefusalOf(error)` reads it with its `meta` typed. **Lines with not enough stock** (19/10): the preview does not refuse them, it SETS THEM APART: `quote.unavailable` has them (`QuoteUnavailableLine`: priced like the others but without discounts, with `availableStock`; the whole line even if some units exist), and `quote.items` and `quote.totals` count only what can be bought. The preview is still asked WITH every line (it is what says which ones are unavailable); the payment is not: `pay()` leaves out the lines the last preview said are unavailable (and their delivery method), and when none is left it throws `NOTHING_TO_PAY` without asking the store. A page pays with a fresh preview; the store's own 400 (`Insufficient stock…`, the last unit sold between the preview and the payment) is what is left, and the page asks for the preview again. **The preview describes the lines too** (19/10): each line of `items` and of `unavailable` carries `variantName`, `productName`, `variantSlug`, `skuCode`, `coverUrl`, `options`, `allowedDeliveryMethods` (what `deliveryMethods` can choose from), `availableStock`, `allowBackorder` and `maxOrderQuantity` (`QuoteLinePresentation`): in the v2 flow it is the ONE call that prices a cart and describes it, and it replaces `/cart/total` (the store reads these from OpenSearch like `/cart/total` does). A site that works this way makes its store with `cartPricing: false` (`CartStoreOptions.pricing`; `@webround/commerce-react/site` does): a guest's lines are kept and counted, `priced` stays null and `/cart/total` is never asked; a customer's cart is still read with `/cart/get`, which is where its lines are. **Delivery**: the preview does not need the customer's delivery choice for every line: one without a choice gets the product's default (shipping, else pickup, else none) in the line's `deliveryMethod`, and `allowedDeliveryMethods` says what else it could be; `pay()` sends the customer's choice or, for a line they did not choose for, the one the last preview gave it. **Tracking**: the store's preview sends the cart's analytics event (`cartTrackingId`, as `/cart/total` did), so a site that never calls `/cart/total` is still tracked. **Paying**: `pay(returnUrls?)` builds the order's body from the same choices, `email` (a guest's: who the order is for) and, for an invoice, both codes (a missing one goes as an empty text for the store to
 refuse); it does not redirect (the site sends the customer to `url`) and is asked once per order. Where the customer comes back to is the argument, else `createCommerce({ returnUrls })`, else `browserReturnUrls` (this page's origin: `/checkout/success?clean_cart=true`
 and `/`, what the site has always sent; the store accepts only its own origin, an allowed one or localhost). **After the payment** (the success page): `commerce.cart.clear()` (a guest's lines and tracking id forgotten in the browser; a customer's cart,
 which the store emptied by itself, is read again) or `commerce.checkout.complete()` (that, and the choices and the preview forgotten). `commerce.checkout` needs `checkoutApiUrl`: a store made without it works, and it throws, saying so, where the checkout is read.

package/dist/index.js

@@ -1,5 +1,5 @@
 // @webround/commerce: the logic of a Webround Commerce store (its catalog, cart, customers, checkout), with no UI and no framework.
-// What a framework needs to use it comes as an adapter of its own (`@webround/commerce/react`, one day `/next`…), never in here.
+// What a framework needs to use it comes as a package of its own (`@webround/commerce-react`, one day `@webround/commerce-next`…), never in here.
 export { cacheKey, cachePrefix, createCache } from './cache.js';
 export { canonicalize, canonicalJson } from './canonical.js';
 export { CommerceError, commerceErrorFromResponse, dataLimitOf, isCommerceError, toCommerceError } from './errors.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webround/commerce",
-    "version": "0.2.0",
+    "version": "0.3.1",
     "type": "module",
     "main": "./dist/index.js",
     "module": "./dist/index.js",
@@ -10,16 +10,6 @@
             "import": "./dist/index.js",
             "types": "./dist/index.d.ts",
             "development": "./src/index.ts"
-        },
-        "./react": {
-            "import": "./dist/react/index.js",
-            "types": "./dist/react/index.d.ts",
-            "development": "./src/react/index.ts"
-        },
-        "./site": {
-            "import": "./dist/site.js",
-            "types": "./dist/site.d.ts",
-            "development": "./src/site.ts"
         }
     },
     "files": [
@@ -41,25 +31,7 @@
         "smoke:wishlist": "node smoke/wishlist.smoke.ts",
         "smoke:reviews": "node smoke/reviews.smoke.ts"
     },
-    "peerDependencies": {
-        "react": ">=19",
-        "@webround/core": "^0.2.0"
-    },
-    "peerDependenciesMeta": {
-        "react": {
-            "optional": true
-        },
-        "@webround/core": {
-            "optional": true
-        }
-    },
     "devDependencies": {
-        "@types/jsdom": "^30.0.0",
-        "@types/react": "^19.3.0",
-        "@types/react-dom": "^19.3.0",
-        "jsdom": "^26.1.0",
-        "react": "^19.3.0",
-        "react-dom": "^19.3.0",
         "typescript": "^5.5.0"
     },
     "publishConfig": {

package/dist/react/index.d.ts

@@ -1,23 +0,0 @@
-export { useResource } from './use-resource.js';
-export type { UseResourceOptions, UseResourceResult } from './use-resource.js';
-export { useShop } from './use-shop.js';
-export type { UseShopOptions, UseShopResult } from './use-shop.js';
-export { useShopAddress } from './use-shop-address.js';
-export type { UseShopAddressOptions } from './use-shop-address.js';
-export { authActions, useAuth } from './use-auth.js';
-export type { AuthActions, UseAuthResult } from './use-auth.js';
-export { cartActions, useCart } from './use-cart.js';
-export type { CartActions, UseCartResult } from './use-cart.js';
-export { useAccount } from './use-account.js';
-export type { UseAccountResult } from './use-account.js';
-export { checkoutActions, useCheckout } from './use-checkout.js';
-export type { CheckoutActions, UseCheckoutOptions, UseCheckoutResult } from './use-checkout.js';
-export { addressActions, useAddresses } from './use-addresses.js';
-export type { AddressActions, UseAddressesResult } from './use-addresses.js';
-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 { useMyReviews, useReviewAbility } from './use-reviews.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/react/index.js

@@ -1,15 +0,0 @@
-// @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 { useShop } from './use-shop.js';
-export { useShopAddress } from './use-shop-address.js';
-export { authActions, useAuth } from './use-auth.js';
-export { cartActions, useCart } from './use-cart.js';
-export { useAccount } from './use-account.js';
-export { checkoutActions, useCheckout } from './use-checkout.js';
-export { addressActions, useAddresses } from './use-addresses.js';
-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 { useMyReviews, useReviewAbility } from './use-reviews.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,12 +0,0 @@
-import { type Account, type NewsletterStrategy } from '../account/account.js';
-import type { Auth } from '../auth/auth.js';
-export interface UseAccountResult {
-    /** What subscribing to, or cancelling, the newsletter will do now. */
-    newsletter: NewsletterStrategy;
-    actions: Account;
-}
-export declare function useAccount(commerce: {
-    account: Account;
-    auth: Pick<Auth, 'store'>;
-}): UseAccountResult;
-//# sourceMappingURL=use-account.d.ts.map

package/dist/react/use-account.js

@@ -1,9 +0,0 @@
-import { useMemo, useSyncExternalStore } from 'react';
-import { newsletterStrategy } from '../account/account.js';
-export function useAccount(commerce) {
-    const { store } = commerce.auth;
-    const state = useSyncExternalStore(store.subscribe, store.getState, store.getState);
-    const newsletter = useMemo(() => newsletterStrategy(state), [state.status, state.customer?.email, state.customer?.emailVerified]);
-    return { newsletter, actions: commerce.account };
-}
-//# sourceMappingURL=use-account.js.map

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

@@ -1,20 +0,0 @@
-import type { AddressBook, AddressBookState } from '../addresses/book.js';
-export interface AddressActions {
-    save: AddressBook['save'];
-    remember: AddressBook['remember'];
-    update: AddressBook['update'];
-    remove: AddressBook['remove'];
-    setDefault: AddressBook['setDefault'];
-    refresh: AddressBook['refresh'];
-}
-export interface UseAddressesResult {
-    state: AddressBookState;
-    addresses: AddressBookState['addresses'];
-    actions: AddressActions;
-}
-export declare function addressActions(book: AddressBook): AddressActions;
-/** `commerce` is what `createCommerce` made (or `@webround/commerce/site`'s). Any number of components can use it: the book starts once. A server render says `unknown` and no addresses. */
-export declare function useAddresses(commerce: {
-    addresses: AddressBook;
-}): UseAddressesResult;
-//# sourceMappingURL=use-addresses.d.ts.map

package/dist/react/use-addresses.js

@@ -1,20 +0,0 @@
-import { useEffect, useMemo, useSyncExternalStore } from 'react';
-export function addressActions(book) {
-    return {
-        save: (input) => book.save(input),
-        remember: (input) => book.remember(input),
-        update: (id, patch) => book.update(id, patch),
-        remove: (id) => book.remove(id),
-        setDefault: (id, kind) => book.setDefault(id, kind),
-        refresh: () => book.refresh(),
-    };
-}
-/** `commerce` is what `createCommerce` made (or `@webround/commerce/site`'s). Any number of components can use it: the book starts once. A server render says `unknown` and no addresses. */
-export function useAddresses(commerce) {
-    const { addresses: book } = 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 };
-}
-//# sourceMappingURL=use-addresses.js.map

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

@@ -1,24 +0,0 @@
-import type { Auth } from '../auth/auth.js';
-import type { AuthState, AuthStatus, AuthStore, Customer } from '../auth/store.js';
-import type { TwoFactorChallenge } from '../auth/types.js';
-/** 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'];
-    login: AuthStore['login'];
-    verifyTwoFactor: AuthStore['verifyTwoFactor'];
-    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;
-    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;
-//# sourceMappingURL=use-auth.d.ts.map

package/dist/react/use-auth.js

@@ -1,20 +0,0 @@
-import { useEffect, useMemo, useSyncExternalStore } from 'react';
-export function authActions(store) {
-    return {
-        signup: (input, options) => store.signup(input, options),
-        login: (input) => store.login(input),
-        verifyTwoFactor: (code) => store.verifyTwoFactor(code),
-        cancelChallenge: () => store.cancelChallenge(),
-        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;
-    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 };
-}
-//# sourceMappingURL=use-auth.js.map

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

@@ -1,27 +0,0 @@
-import type { CartState, CartStore } from '../cart/store.js';
-export interface CartActions {
-    add: CartStore['add'];
-    setQuantity: CartStore['setQuantity'];
-    remove: CartStore['remove'];
-    /** Empties the cart (a guest's and a customer's). */
-    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'];
-    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.
- */
-/** `commerce` is what `createCommerce` made (or `@webround/commerce/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: {
-    cart: CartStore;
-}): UseCartResult;
-//# sourceMappingURL=use-cart.d.ts.map

package/dist/react/use-cart.js

@@ -1,23 +0,0 @@
-import { useEffect, useMemo, useSyncExternalStore } from 'react';
-export function cartActions(store) {
-    return {
-        add: (line) => store.add(line),
-        setQuantity: (variantId, quantity) => store.setQuantity(variantId, quantity),
-        remove: (variantId) => store.remove(variantId),
-        clear: () => store.clear(),
-        refresh: () => store.refresh(),
-    };
-}
-/**
- * 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.
- */
-/** `commerce` is what `createCommerce` made (or `@webround/commerce/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) {
-    const { cart } = 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 };
-}
-//# sourceMappingURL=use-cart.js.map

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

@@ -1,37 +0,0 @@
-import type { CheckoutState, CheckoutStore } from '../checkout/store.js';
-export interface CheckoutActions {
-    setDeliveryMethod: CheckoutStore['setDeliveryMethod'];
-    setShippingAddress: CheckoutStore['setShippingAddress'];
-    setBillingAddress: CheckoutStore['setBillingAddress'];
-    selectShippingMethod: CheckoutStore['selectShippingMethod'];
-    setPromotionCodes: CheckoutStore['setPromotionCodes'];
-    setAdditionalData: CheckoutStore['setAdditionalData'];
-    setEmail: CheckoutStore['setEmail'];
-    setInvoice: CheckoutStore['setInvoice'];
-    /** Asks the preview now (what it asked automatically is asked again). Throws what the store refuses. */
-    quote: CheckoutStore['quote'];
-    /** Starts the payment; give the customer the `url` it answers (`location.assign(url)`). Throws what the store refuses. */
-    pay: CheckoutStore['pay'];
-    reset: CheckoutStore['reset'];
-    /** The payment is done (the success page): empties the cart and forgets the checkout. */
-    complete: CheckoutStore['complete'];
-}
-export interface UseCheckoutOptions {
-    /**
-     * Ask the preview by itself when the cart or what the customer chose changes (default: yes). Not for an empty cart, and not again for what already failed (ask again with `actions.quote`). A refusal is not thrown
-     * here: it is in `state.error`.
-     */
-    autoQuote?: boolean;
-}
-export interface UseCheckoutResult {
-    state: CheckoutState;
-    /** What the store says it costs (null until it said); `state.isStale` when it is the answer to something the customer has since changed. */
-    quote: CheckoutState['quote'];
-    actions: CheckoutActions;
-}
-export declare function checkoutActions(store: CheckoutStore): CheckoutActions;
-/** `commerce` is what `createCommerce` made (or `@webround/commerce/site`'s). Reading `commerce.checkout` needs the checkout API's address. */
-export declare function useCheckout(commerce: {
-    checkout: CheckoutStore;
-}, options?: UseCheckoutOptions): UseCheckoutResult;
-//# sourceMappingURL=use-checkout.d.ts.map

package/dist/react/use-checkout.js

@@ -1,33 +0,0 @@
-import { useEffect, useMemo, useSyncExternalStore } from 'react';
-export function checkoutActions(store) {
-    return {
-        setDeliveryMethod: (variantId, method) => store.setDeliveryMethod(variantId, method),
-        setShippingAddress: (address) => store.setShippingAddress(address),
-        setBillingAddress: (address) => store.setBillingAddress(address),
-        selectShippingMethod: (id) => store.selectShippingMethod(id),
-        setPromotionCodes: (codes) => store.setPromotionCodes(codes),
-        setAdditionalData: (data) => store.setAdditionalData(data),
-        setEmail: (email) => store.setEmail(email),
-        setInvoice: (invoice) => store.setInvoice(invoice),
-        quote: (options) => store.quote(options),
-        pay: (returnUrls) => store.pay(returnUrls),
-        reset: () => store.reset(),
-        complete: () => store.complete(),
-    };
-}
-/** `commerce` is what `createCommerce` made (or `@webround/commerce/site`'s). Reading `commerce.checkout` needs the checkout API's address. */
-export function useCheckout(commerce, options = {}) {
-    const { checkout } = commerce;
-    const autoQuote = options.autoQuote ?? true;
-    const state = useSyncExternalStore(checkout.subscribe, checkout.getState, checkout.getState);
-    const actions = useMemo(() => checkoutActions(checkout), [checkout]);
-    useEffect(() => { checkout.start(); }, [checkout]);
-    // Which questions were asked is the store's to remember (one for all the components): a refusal is not asked again by itself, and the same question is never asked twice
-    useEffect(() => {
-        if (!autoQuote)
-            return;
-        checkout.ensureQuote().catch(() => { });
-    }, [checkout, autoQuote, state.requestKey, state.lineCount]);
-    return { state, quote: state.quote, actions };
-}
-//# sourceMappingURL=use-checkout.js.map

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

@@ -1,5 +0,0 @@
-import type { Auth } from '../auth/auth.js';
-import type { Resource } from '../resource.js';
-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>;
-//# sourceMappingURL=use-customer-resource.d.ts.map

package/dist/react/use-customer-resource.js

@@ -1,9 +0,0 @@
-import { useSyncExternalStore } from 'react';
-import { useResource } from './use-resource.js';
-// A resource that is about the logged-in customer, shown by a component: the same as `useResource`, plus that the component follows who is logged in. Nobody logged in is no resource (`idle`), and logging in or out draws
-// the component again with the right one (the cache forgets what was the customer's when they go).
-export function useCustomerResource(auth, make, options) {
-    useSyncExternalStore(auth.store.subscribe, auth.store.getState, auth.store.getState);
-    return useResource(make(), options);
-}
-//# sourceMappingURL=use-customer-resource.js.map

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

@@ -1,14 +0,0 @@
-import type { Auth } from '../auth/auth.js';
-import type { Orders } from '../orders/orders.js';
-import type { Order, OrderPage, PageQuery, Subscription, SubscriptionPage } from '../orders/types.js';
-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 useSubscriptions: (commerce: Source, query?: PageQuery, options?: UseResourceOptions) => UseResourceResult<SubscriptionPage>;
-export declare const useSubscription: (commerce: Source, id: string | null | undefined) => UseResourceResult<Subscription>;
-export {};
-//# sourceMappingURL=use-orders.d.ts.map

package/dist/react/use-orders.js

@@ -1,6 +0,0 @@
-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));
-//# sourceMappingURL=use-orders.js.map

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

@@ -1,25 +0,0 @@
-import type { Resource } from '../resource.js';
-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.
-     */
-    keepPrevious?: boolean;
-}
-export interface UseResourceResult<T> {
-    /** `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. */
-    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;
-}
-/** 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>;
-//# sourceMappingURL=use-resource.d.ts.map

package/dist/react/use-resource.js

@@ -1,60 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
-const NOTHING = { status: 'idle' };
-const noSubscription = () => () => undefined;
-/** 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 function useResource(resource, options = {}) {
-    const keepPrevious = options.keepPrevious === true;
-    const key = resource?.key;
-    // A resource is made again at every render, and the same key is the same question: only a new key is a new one (what is subscribed to must not change on every render)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    const asked = useMemo(() => resource ?? null, [key]);
-    const subscribe = useCallback((listener) => (asked ? asked.subscribe(listener) : noSubscription()), [asked]);
-    const read = useCallback(() => (asked ? asked.snapshot() : NOTHING), [asked]);
-    // The server has the same state as the client: what the cache holds when it renders (a prerender fills it before)
-    const snapshot = useSyncExternalStore(subscribe, read, read);
-    // Asks when the question is there, and gives it up when it is gone: a question nobody waits for any more is not asked (the cache sees to that)
-    const waiting = useRef(null);
-    useEffect(() => {
-        if (!asked)
-            return;
-        const controller = (waiting.current = new AbortController());
-        if (asked.snapshot().status !== 'ready')
-            asked.load({ signal: controller.signal }).catch(() => undefined); // the failure is the state of the key, read above
-        return () => { controller.abort(); if (waiting.current === controller)
-            waiting.current = null; };
-    }, [asked]);
-    // What is watched was forgotten (it was invalidated in the catalog): it is asked again, so that what is on the screen is never "nothing" for good
-    const forgotten = asked !== null && snapshot.status === 'idle';
-    useEffect(() => {
-        if (forgotten && waiting.current && asked && asked.snapshot().status === 'idle')
-            asked.load({ signal: waiting.current.signal }).catch(() => undefined);
-    }, [forgotten, asked]);
-    const retrying = useRef(null);
-    useEffect(() => () => { retrying.current?.abort(); retrying.current = null; }, [asked]);
-    const retry = useCallback(() => {
-        if (!asked || asked.snapshot().status !== 'error')
-            return;
-        retrying.current?.abort();
-        const controller = (retrying.current = new AbortController());
-        asked.load({ signal: controller.signal }).catch(() => undefined);
-    }, [asked]);
-    // The last answer that was shown, for `keepPrevious`: kept once it is on the screen
-    const shown = useRef(undefined);
-    const hasShown = useRef(false);
-    useEffect(() => {
-        if (snapshot.status === 'ready') {
-            shown.current = snapshot.data;
-            hasShown.current = true;
-        }
-    }, [snapshot]);
-    if (!asked)
-        return { status: 'idle', data: undefined, error: undefined, isFetching: false, isStale: false, retry };
-    if (snapshot.status === 'ready')
-        return { status: 'ready', data: snapshot.data, error: undefined, isFetching: false, isStale: false, retry };
-    if (snapshot.status === 'error')
-        return { status: 'error', data: undefined, error: snapshot.error, isFetching: false, isStale: false, retry };
-    // `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 };
-}
-//# sourceMappingURL=use-resource.js.map

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

@@ -1,14 +0,0 @@
-import type { Auth } from '../auth/auth.js';
-import type { Returns } from '../returns/returns.js';
-import type { GuestReturnSession, PageQuery, ReturnRequest, ReturnRequestPage } from '../returns/types.js';
-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>;
-/** 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 {};
-//# sourceMappingURL=use-returns.d.ts.map

package/dist/react/use-returns.js

@@ -1,7 +0,0 @@
-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));
-/** 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);
-//# sourceMappingURL=use-returns.js.map

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

@@ -1,14 +0,0 @@
-import type { Auth } from '../auth/auth.js';
-import { type ReviewAbility } from '../reviews/rules.js';
-import type { Reviews } from '../reviews/reviews.js';
-import type { MyReviewPage, MyReviewsQuery } from '../reviews/types.js';
-import type { UseResourceOptions, UseResourceResult } from './use-resource.js';
-type Source = {
-    auth: Pick<Auth, 'store'>;
-    reviews: Reviews;
-};
-export declare const useMyReviews: (commerce: Source, query?: MyReviewsQuery, options?: UseResourceOptions) => UseResourceResult<MyReviewPage>;
-/** 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 declare function useReviewAbility(commerce: Pick<Source, 'auth'>): ReviewAbility;
-export {};
-//# sourceMappingURL=use-reviews.d.ts.map

package/dist/react/use-reviews.js

@@ -1,10 +0,0 @@
-import { useSyncExternalStore } from 'react';
-import { reviewAbility } from '../reviews/rules.js';
-import { useCustomerResource } from './use-customer-resource.js';
-export const useMyReviews = (commerce, query, options = { keepPrevious: true }) => useCustomerResource(commerce.auth, () => commerce.reviews.mine(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);
-    return reviewAbility(state);
-}
-//# sourceMappingURL=use-reviews.js.map

package/dist/react/use-shop-address.d.ts

@@ -1,12 +0,0 @@
-import type { AddressOptions } from '../shop/address.js';
-import type { ShopStore } from '../shop/store.js';
-export interface UseShopAddressOptions extends AddressOptions {
-    /** The query string of the address NOW, as the router gives it (`location.search`). */
-    search: string;
-    /** Goes to this query string, on the same page, adding a history entry (`navigate({ search })` of react-router). */
-    navigate: (search: string) => void;
-    /** The collection the page is for (from its route): it is not in the query. */
-    collectionId?: string;
-}
-export declare function useShopAddress(options: UseShopAddressOptions): ShopStore;
-//# sourceMappingURL=use-shop-address.d.ts.map

package/dist/react/use-shop-address.js

@@ -1,39 +0,0 @@
-import { useEffect, useMemo, useRef } from 'react';
-import { createAddressShopStore } from '../shop/address-store.js';
-export function useShopAddress(options) {
-    const { search, collectionId, limit } = options;
-    // What the port calls is always the latest the site gave, without the store being made again at every render
-    const navigate = useRef(options.navigate);
-    navigate.current = options.navigate;
-    const listeners = useRef(new Set());
-    // What the address says now: what the router said last, or what was written since (until the router says it too)
-    const shown = useRef(search);
-    const routerSaid = useRef(search);
-    // The router says something else than before (the back button, a link): THAT is the address, already in this render (no frame with the old one). Only a change of what the router says counts:
-    // a render that comes between a write and the router's answer must not take the address back.
-    if (routerSaid.current !== search) {
-        routerSaid.current = search;
-        shown.current = search;
-    }
-    const port = useMemo(() => ({
-        read: () => shown.current,
-        write(next) {
-            shown.current = next;
-            for (const listener of [...listeners.current])
-                listener();
-            navigate.current(next);
-        },
-        subscribe(listener) {
-            listeners.current.add(listener);
-            return () => { listeners.current.delete(listener); };
-        },
-    }), []);
-    // Whoever listens (another component with the same store) is told that the address may have changed: if what the shop says is the same, it is the same state and nothing is drawn again
-    useEffect(() => {
-        for (const listener of [...listeners.current])
-            listener();
-    }, [search]);
-    // A new store when the page's collection or the shop's limit change: it is the same address read with other defaults
-    return useMemo(() => createAddressShopStore(port, { collectionId, limit }), [port, collectionId, limit]);
-}
-//# sourceMappingURL=use-shop-address.js.map

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

@@ -1,34 +0,0 @@
-import type { CachedCatalog } from '../catalog/cached.js';
-import type { ProductPage, ProductSearch, StoreDataResponse } from '../catalog/types.js';
-import { type SortOption } from '../shop/sort.js';
-import type { ShopState } from '../shop/state.js';
-import { type ShopActions, type ShopStore } from '../shop/store.js';
-import type { SearchContext } from '../shop/to-search.js';
-import { type UseResourceResult } 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). */
-    initial?: ShopState;
-    /** Where the state lives, when it is not in memory in the hook (an address bar, a store the page owns). */
-    store?: ShopStore;
-    /** 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. */
-    state: ShopState;
-    /** What changes it. */
-    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. */
-    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;
-//# sourceMappingURL=use-shop.d.ts.map

package/dist/react/use-shop.js

@@ -1,31 +0,0 @@
-import { useCallback, useMemo, useRef, useSyncExternalStore } from 'react';
-import { canonicalJson } from '../canonical.js';
-import { shopQuestion } from '../shop/question.js';
-import { sortOptionsOf } from '../shop/sort.js';
-import { createShopStore, shopActions } from '../shop/store.js';
-import { useResource } from './use-resource.js';
-export function useShop(options) {
-    const { catalog, context, keepPrevious = true } = options;
-    // The state: in memory, in the hook, unless a store was given
-    const own = useRef(null);
-    if (!options.store && !own.current)
-        own.current = createShopStore(options.initial);
-    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;
-    // 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 products = useResource(asked?.resource ?? null, { keepPrevious });
-    const sortOptions = useMemo(() => (data ? sortOptionsOf(data) : []), [data]);
-    // 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
-        ? 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 };
-}
-//# sourceMappingURL=use-shop.js.map

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

@@ -1,15 +0,0 @@
-import { type Wishlist, type WishlistState } from '../wishlist/wishlist.js';
-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. */
-    toggle: Wishlist['toggle'];
-    refresh: Wishlist['refresh'];
-}
-/** `commerce` is what `createCommerce` made (or `@webround/commerce/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;
-}): UseWishlistResult;
-//# sourceMappingURL=use-wishlist.d.ts.map

package/dist/react/use-wishlist.js

@@ -1,12 +0,0 @@
-import { useCallback, useEffect, useMemo, useSyncExternalStore } from 'react';
-import { isInWishlist } from '../wishlist/wishlist.js';
-/** `commerce` is what `createCommerce` made (or `@webround/commerce/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 function useWishlist(commerce) {
-    const { wishlist } = commerce;
-    const state = useSyncExternalStore(wishlist.subscribe, wishlist.getState, wishlist.getState);
-    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 };
-}
-//# sourceMappingURL=use-wishlist.js.map

package/dist/returns/rules.d.ts

@@ -1,7 +0,0 @@
-import { type AddressIssue } from '../addresses/rules.js';
-import { type CreateGuestReturnInput, type CreateReturnInput } from './types.js';
-/** What is wrong with a return request, in the shape the store lists it (`path`, `message`). The order or the token is the caller's to check (it is an id, not something to write). */
-export declare function returnIssues(input: Pick<CreateReturnInput, 'items' | 'reason' | 'shippingAddress' | 'billingAddress'>): AddressIssue[];
-/** The request as it is, or the refusal the store would have given (400, what it did not like in `issues`). */
-export declare function checkedReturn<T extends CreateReturnInput | CreateGuestReturnInput>(input: T): T;
-//# sourceMappingURL=rules.d.ts.map

package/dist/returns/rules.js

@@ -1,45 +0,0 @@
-import { CommerceError } from '../errors.js';
-import { addressIssues } from '../addresses/rules.js';
-import { RETURN_LIMITS } from './types.js';
-// What a return request has to meet (the store's own rule), said before asking: a form can show what is wrong without a round trip. Pure.
-/** What is wrong with a return request, in the shape the store lists it (`path`, `message`). The order or the token is the caller's to check (it is an id, not something to write). */
-export function returnIssues(input) {
-    const issues = [];
-    if (!Array.isArray(input.items) || input.items.length < 1)
-        issues.push({ path: ['items'], message: 'Choose at least one item to return' });
-    else if (input.items.length > RETURN_LIMITS.items)
-        issues.push({ path: ['items'], message: `At most ${RETURN_LIMITS.items} items` });
-    else {
-        const seen = new Set();
-        input.items.forEach((item, i) => {
-            if (!item || typeof item.orderItemId !== 'string' || item.orderItemId === '')
-                issues.push({ path: ['items', String(i), 'orderItemId'], message: 'Required' });
-            else if (seen.has(item.orderItemId))
-                issues.push({ path: ['items', String(i), 'orderItemId'], message: 'The same item twice' });
-            else
-                seen.add(item.orderItemId);
-            if (!item || !Number.isInteger(item.quantity) || item.quantity < 1 || item.quantity > RETURN_LIMITS.quantity)
-                issues.push({ path: ['items', String(i), 'quantity'], message: `A whole number from 1 to ${RETURN_LIMITS.quantity}` });
-        });
-    }
-    if (input.reason !== undefined && input.reason.length > RETURN_LIMITS.reason)
-        issues.push({ path: ['reason'], message: `At most ${RETURN_LIMITS.reason} characters` });
-    for (const which of ['shippingAddress', 'billingAddress']) {
-        const address = input[which];
-        if (!address) {
-            issues.push({ path: [which], message: 'Required' });
-            continue;
-        }
-        for (const issue of addressIssues(address))
-            issues.push({ path: [which, ...issue.path], message: issue.message });
-    }
-    return issues;
-}
-/** The request as it is, or the refusal the store would have given (400, what it did not like in `issues`). */
-export function checkedReturn(input) {
-    const issues = returnIssues(input);
-    if (issues.length > 0)
-        throw new CommerceError({ kind: 'http', status: 400, code: null, message: issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; '), issues });
-    return input;
-}
-//# sourceMappingURL=rules.js.map

package/dist/site.d.ts

@@ -1,7 +0,0 @@
-import { type WrSiteEnv } from '@webround/core/site-env';
-import { type Commerce, type CommerceConfig } from './commerce.js';
-/** The store `env` describes. Throws, naming what is missing, when it does not say enough. */
-export declare function commerceFromEnv(env: WrSiteEnv, options?: Omit<CommerceConfig, 'storeId' | 'commerceApiUrl' | 'catalogApiUrl' | 'checkoutApiUrl'>): Commerce;
-/** This site's store: its session, its catalog, its cache. Made the first time one of them is read. */
-export declare const commerce: Commerce;
-//# sourceMappingURL=site.d.ts.map

package/dist/site.js

@@ -1,41 +0,0 @@
-import { wrSiteEnv, WR_SITE_ENV_VARS } from '@webround/core/site-env';
-import { createCommerce } from './commerce.js';
-// `@webround/commerce/site`: the store of THIS site, made from what the site was built with (`VITE_WR_*`, set by the Worker that runs the draft; `wrSiteEnv` of @webround/core is the one place that reads them).
-//
-//   import { commerce } from '@webround/commerce/site';
-//   const { actions } = useAuth(commerce.auth);
-//
-// Nothing is made until it is used: a page that never touches the store costs nothing, and a site built without the variables fails WHERE it uses the store, saying which one is missing, not when it loads.
-/** The store `env` describes. Throws, naming what is missing, when it does not say enough. */
-export function commerceFromEnv(env, options = {}) {
-    const { draftId, commerceApiUrl, catalogApiUrl, checkoutApiUrl } = env;
-    if (draftId === undefined || commerceApiUrl === undefined || catalogApiUrl === undefined) {
-        const missing = [
-            draftId === undefined ? WR_SITE_ENV_VARS.draftId : null,
-            commerceApiUrl === undefined ? WR_SITE_ENV_VARS.commerceApiUrl : null,
-            catalogApiUrl === undefined ? WR_SITE_ENV_VARS.catalogApiUrl : null,
-        ].filter((name) => name !== null);
-        throw new Error(`@webround/commerce: this site was built without ${missing.join(', ')}, so it does not know which store to talk to.`);
-    }
-    // The checkout's address is not needed to run the store: a site without it fails where it uses the checkout, saying so
-    return createCommerce({ ...options, storeId: draftId, commerceApiUrl, catalogApiUrl, ...(checkoutApiUrl !== undefined ? { checkoutApiUrl } : {}) });
-}
-let made;
-// This site prices and describes its cart with the checkout's preview (`commerce.checkout`): `/cart/total` is never asked
-const store = () => (made ?? (made = commerceFromEnv(wrSiteEnv(), { cartPricing: false })));
-/** This site's store: its session, its catalog, its cache. Made the first time one of them is read. */
-export const commerce = {
-    get storeId() { return store().storeId; },
-    get auth() { return store().auth; },
-    get catalog() { return store().catalog; },
-    get cache() { return store().cache; },
-    get cart() { return store().cart; },
-    get checkout() { return store().checkout; },
-    get account() { return store().account; },
-    get addresses() { return store().addresses; },
-    get orders() { return store().orders; },
-    get returns() { return store().returns; },
-    get wishlist() { return store().wishlist; },
-    get reviews() { return store().reviews; },
-};
-//# sourceMappingURL=site.js.map