@webround/commerce 0.0.0-stage → 0.3.0

package/dist/returns/index.js

@@ -0,0 +1,3 @@
+export { createReturnApi } from './api.js';
+export { createReturns } from './returns.js';
+//# sourceMappingURL=index.js.map

package/dist/returns/returns.d.ts

@@ -0,0 +1,30 @@
+import type { CustomerResources } from '../customer-resources.js';
+import type { Cache } from '../cache.js';
+import { type Resource, type ResourceIdentity } from '../resource.js';
+import type { ReturnApi } from './api.js';
+import type { CreateGuestReturnInput, CreateReturnInput, GuestReturnSession, GuestVerifyAnswer, GuestVerifyInput, PageQuery, ReturnRequest, ReturnRequestPage } from './types.js';
+export interface Returns {
+    list(query?: PageQuery): Resource<ReturnRequestPage> | null;
+    get(id: string): Resource<ReturnRequest> | null;
+    /** Asks to return some of the items of an order. Throws what the store refuses (an order that is not the customer's: 404). */
+    create(input: CreateReturnInput): Promise<ReturnRequest>;
+    /** Cancels a request that is still pending (the store refuses any other: 400). */
+    cancel(id: string): Promise<ReturnRequest>;
+    guest: {
+        /** Asks the store to email the link (it answers the same whether the order exists or not). */
+        requestLink(input: GuestVerifyInput): Promise<GuestVerifyAnswer>;
+        /** The order the link's token opens: a resource, so a page shows it (and what is asked of the same token is asked once). */
+        session(token: string): Resource<GuestReturnSession>;
+        create(input: CreateGuestReturnInput): Promise<ReturnRequest>;
+        cancel(id: string, token: string): Promise<ReturnRequest>;
+    };
+    /** Forgets what was kept of the customer's requests, so the next question is asked again. */
+    refresh(): void;
+}
+export declare function createReturns(options: {
+    api: ReturnApi;
+    customer: CustomerResources;
+    cache: Cache;
+    identity: ResourceIdentity;
+}): Returns;
+//# sourceMappingURL=returns.d.ts.map

package/dist/returns/returns.js

@@ -0,0 +1,31 @@
+import { createResourceFactory } from '../resource.js';
+export function createReturns(options) {
+    const { api, customer } = options;
+    const make = createResourceFactory(options.cache, options.identity);
+    const forgetMine = () => { customer.forget('returns.list'); customer.forget('returns.get'); };
+    return {
+        list: (query) => customer.resource('returns.list', undefined, query ?? {}, (o) => api.list(query, o)),
+        get: (id) => customer.resource('returns.get', id, undefined, (o) => api.get(id, o)),
+        async create(input) {
+            const made = await api.create(input);
+            forgetMine();
+            return made;
+        },
+        async cancel(id) {
+            try {
+                return await api.cancel(id);
+            }
+            finally {
+                forgetMine();
+            }
+        },
+        guest: {
+            requestLink: (input) => api.verifyGuest(input),
+            session: (token) => make('returns.guestSession', token, undefined, (o) => api.guestSession(token, o)),
+            create: (input) => api.createGuest(input),
+            cancel: (id, token) => api.cancelGuest(id, token),
+        },
+        refresh: forgetMine,
+    };
+}
+//# sourceMappingURL=returns.js.map

package/dist/returns/types.d.ts

@@ -0,0 +1,99 @@
+import type { OrderAddress, Page, PageQuery } from '../orders/types.js';
+export type ReturnStatus = 'pending' | 'accepted' | 'rejected' | 'refunded';
+/** One item of a return: which item of the order (`orderItemId` of an `OrderItem`) and how many of it. */
+export interface ReturnItemInput {
+    orderItemId: string;
+    quantity: number;
+}
+/** What a customer sends to return (some of) an order. */
+export interface CreateReturnInput {
+    orderId: string;
+    items: ReturnItemInput[];
+    reason?: string;
+    /** Where the store is to collect or send what concerns the return, and who it bills. */
+    shippingAddress: OrderAddress;
+    billingAddress: OrderAddress;
+}
+/** What a guest sends: the same, with the link's token in place of the order (the token says which). */
+export interface CreateGuestReturnInput extends Omit<CreateReturnInput, 'orderId'> {
+    token: string;
+}
+export interface ReturnItem {
+    orderItemId: string;
+    variantId: string;
+    variantName: string;
+    coverUrl?: string | null;
+    quantity: number;
+    unitNet: string;
+    unitGross: string;
+    unitTax: string;
+    totalNet: string;
+    totalGross: string;
+    totalTax: string;
+    appliedTaxRate: number;
+    taxBehavior: string;
+    skuCode: string | null;
+}
+export interface ReturnRequest {
+    id: string;
+    storeId: string;
+    orderId: string;
+    orderReference: number | null;
+    customerId: string;
+    status: ReturnStatus;
+    items: ReturnItem[];
+    reason: string | null;
+    shippingAddress: OrderAddress | null;
+    billingAddress: OrderAddress | null;
+    customerEmail: string;
+    submittedAt: string;
+    /** What the store wrote when it answered. */
+    merchantNote: string | null;
+    processedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export type ReturnRequestPage = Page<ReturnRequest>;
+export type { PageQuery };
+/** How a guest says which order: the address it was bought with, and the order's id OR its reference (the number the customer was given). */
+export interface GuestVerifyInput {
+    customerEmail: string;
+    orderId?: string;
+    reference?: number;
+}
+/** What the store answers to asking for the link: the same whatever the order (it does not tell whether one exists). */
+export interface GuestVerifyAnswer {
+    message: string;
+}
+export interface GuestOrderItem {
+    orderItemId: string;
+    variantId: string | null;
+    coverUrl: string | null;
+    name: string;
+    skuCode: string | null;
+    quantity: number | null;
+    unitNet: string | null;
+    unitGross: string | null;
+    unitTax: string | null;
+    totalNet: string | null;
+    totalGross: string | null;
+    totalTax: string | null;
+    appliedTaxRate: number | null;
+    taxBehavior: string | null;
+}
+/** What the link's token opens: the order, to choose what to return from. */
+export interface GuestReturnSession {
+    success: boolean;
+    order: {
+        id: string;
+        reference: number | null;
+        customerEmail: string;
+        shippingAddress: OrderAddress | null;
+        billingAddress: OrderAddress | null;
+        currencyCode: string;
+        amount: string | null;
+        createdAt: string;
+        items: GuestOrderItem[];
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/returns/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/reviews/api.d.ts

@@ -0,0 +1,19 @@
+import type { HttpClient } from '../http.js';
+import type { CallOptions } from '../catalog/types.js';
+import type { AccessTokenOptions } from '../auth/api.js';
+import type { MyReviewPage, MyReviewsQuery, ReviewAnswer, ReviewDeletedAnswer, ReviewInput, ReviewPatch } from './types.js';
+export interface ReviewApi {
+    /** `GET /reviews/by-customer`: the customer's own reviews, a page at a time. */
+    mine(input?: MyReviewsQuery, options?: CallOptions & AccessTokenOptions): Promise<MyReviewPage>;
+    /**
+     * `POST /reviews/product-variants/:variantId`: writes the customer's review of a variant (`201`). Refused with `EMAIL_NOT_VERIFIED` (400: the address is not verified), `REVIEW_ALREADY_EXISTS` (409) and 404
+     * for a variant that is not the store's.
+     */
+    create(variantId: string, input: ReviewInput, options?: CallOptions & AccessTokenOptions): Promise<ReviewAnswer>;
+    /** `PATCH /reviews/:id`: changes what is given of the customer's own review. */
+    update(id: string, patch: ReviewPatch, options?: CallOptions & AccessTokenOptions): Promise<ReviewAnswer>;
+    /** `DELETE /reviews/:id`: removes the customer's own review. */
+    remove(id: string, options?: CallOptions & AccessTokenOptions): Promise<ReviewDeletedAnswer>;
+}
+export declare function createReviewApi(http: HttpClient): ReviewApi;
+//# sourceMappingURL=api.d.ts.map

package/dist/reviews/api.js

@@ -0,0 +1,15 @@
+// The calls of commerce-core that are about what a customer writes of what they bought (`/reviews`), each asking one thing and giving back what the store answers, unchanged (what it writes or removes comes in `data`).
+// All need the JWT of the customer; a store can turn reviews off (403 "Reviews are disabled for this store"). Reading everybody's reviews of a product is the catalog's.
+const bearer = (options) => (options?.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : {});
+const part = (id) => encodeURIComponent(id);
+export function createReviewApi(http) {
+    return {
+        mine: (input, options) => http.request({
+            path: '/reviews/by-customer', query: { page: input?.page, limit: input?.limit, sortBy: input?.sortBy, sortDirection: input?.sortDirection, rating: input?.rating, lang: input?.lang }, headers: bearer(options), signal: options?.signal,
+        }),
+        create: (variantId, input, options) => http.request({ method: 'POST', path: `/reviews/product-variants/${part(variantId)}`, body: input, headers: bearer(options), signal: options?.signal }),
+        update: (id, patch, options) => http.request({ method: 'PATCH', path: `/reviews/${part(id)}`, body: patch, headers: bearer(options), signal: options?.signal }),
+        remove: (id, options) => http.request({ method: 'DELETE', path: `/reviews/${part(id)}`, headers: bearer(options), signal: options?.signal }),
+    };
+}
+//# sourceMappingURL=api.js.map

package/dist/reviews/index.d.ts

@@ -0,0 +1,9 @@
+export { createReviewApi } from './api.js';
+export type { ReviewApi } from './api.js';
+export { createReviews } from './reviews.js';
+export type { Reviews } from './reviews.js';
+export { reviewAbility } from './rules.js';
+export type { ReviewAbility } from './rules.js';
+export { REVIEW_ERROR_CODES } from './types.js';
+export type { MyReview, MyReviewPage, MyReviewsQuery, CustomerReview, ReviewAnswer, ReviewDeletedAnswer, ReviewInput, ReviewPatch } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/reviews/index.js

@@ -0,0 +1,5 @@
+export { createReviewApi } from './api.js';
+export { createReviews } from './reviews.js';
+export { reviewAbility } from './rules.js';
+export { REVIEW_ERROR_CODES } from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/reviews/reviews.d.ts

@@ -0,0 +1,23 @@
+import type { AuthStore } from '../auth/store.js';
+import type { CachedCatalog } from '../catalog/cached.js';
+import type { CustomerResources } from '../customer-resources.js';
+import type { Resource } from '../resource.js';
+import type { ReviewApi } from './api.js';
+import { type MyReviewPage, type MyReviewsQuery, type CustomerReview, type ReviewInput, type ReviewPatch } from './types.js';
+export interface Reviews {
+    mine(query?: MyReviewsQuery): Resource<MyReviewPage> | null;
+    /** Writes the customer's review of a variant. Throws what the store refuses (`EMAIL_NOT_VERIFIED`, `REVIEW_ALREADY_EXISTS`, a variant that is not the store's) and, for a guest, `LOGIN_REQUIRED`. */
+    create(variantId: string, input: ReviewInput): Promise<CustomerReview>;
+    update(id: string, patch: ReviewPatch): Promise<CustomerReview>;
+    /** Removes the customer's own review; says which. */
+    remove(id: string): Promise<{
+        id: string;
+    }>;
+}
+export declare function createReviews(options: {
+    api: ReviewApi;
+    customer: CustomerResources;
+    catalog: Pick<CachedCatalog, 'invalidate'>;
+    auth: Pick<AuthStore, 'getState'>;
+}): Reviews;
+//# sourceMappingURL=reviews.d.ts.map

package/dist/reviews/reviews.js

@@ -0,0 +1,37 @@
+import { CommerceError } from '../errors.js';
+import { REVIEW_ERROR_CODES } from './types.js';
+export function createReviews(options) {
+    const { api, customer, catalog, auth } = options;
+    const loggedIn = () => auth.getState().status === 'signedIn';
+    const login = () => new CommerceError({ kind: 'http', status: 401, code: REVIEW_ERROR_CODES.loginRequired, message: 'Log in to write a review.' });
+    /** What was kept that a review changes: the customer's own, and the catalog's reviews of its product (all of them when the product is not known). */
+    const forget = (productId) => {
+        customer.forget('reviews.mine');
+        catalog.invalidate(productId ? { call: 'products.getReviews', subject: productId } : { call: 'products.getReviews' });
+    };
+    return {
+        mine: (query) => customer.resource('reviews.mine', undefined, query ?? {}, (o) => api.mine(query, o)),
+        async create(variantId, input) {
+            if (!loggedIn())
+                throw login();
+            const { data } = await api.create(variantId, input);
+            forget(data.productId);
+            return data;
+        },
+        async update(id, patch) {
+            if (!loggedIn())
+                throw login();
+            const { data } = await api.update(id, patch);
+            forget(data.productId);
+            return data;
+        },
+        async remove(id) {
+            if (!loggedIn())
+                throw login();
+            const { data } = await api.remove(id);
+            forget();
+            return data;
+        },
+    };
+}
+//# sourceMappingURL=reviews.js.map

package/dist/reviews/rules.d.ts

@@ -0,0 +1,8 @@
+import type { AuthState } from '../auth/store.js';
+/**
+ * Who can write a review, from what the session says: a guest has to log in; a customer whose address is not verified has to verify it (the store refuses with `EMAIL_NOT_VERIFIED`); a customer whose address is verified can.
+ * It is a hint for the screen: the store decides (the session may be one verification behind).
+ */
+export type ReviewAbility = 'login' | 'verify' | 'allowed';
+export declare function reviewAbility(auth: Pick<AuthState, 'status' | 'customer'>): ReviewAbility;
+//# sourceMappingURL=rules.d.ts.map

package/dist/reviews/rules.js

@@ -0,0 +1,7 @@
+export function reviewAbility(auth) {
+    const customer = auth.status === 'signedIn' ? auth.customer : null;
+    if (!customer)
+        return 'login';
+    return customer.emailVerified ? 'allowed' : 'verify';
+}
+//# sourceMappingURL=rules.js.map

package/dist/reviews/types.d.ts

@@ -0,0 +1,54 @@
+import type { Page, PageQuery } from '../orders/types.js';
+export interface ReviewInput {
+    rating: number;
+    title: string;
+    comment: string;
+}
+/** What is changed of a review: any of it. */
+export type ReviewPatch = Partial<ReviewInput>;
+export interface CustomerReview {
+    id: string;
+    storeId: string;
+    productId: string;
+    variantId: string;
+    customerId: string;
+    rating: number;
+    title: string | null;
+    comment: string | null;
+    /** The reviewer bought what they review. */
+    verifiedPurchase: boolean;
+    createdAt: string | null;
+    updatedAt: string | null;
+    /** The reviewer's name: in the customer's list; NOT in what writing or changing a review answers (the store sends the row it kept, which has none). */
+    customerName?: string | null;
+}
+/** A review in the customer's own list: with what it is about. */
+export interface MyReview extends CustomerReview {
+    productVariantName?: string | null;
+    coverUrl?: string | null;
+}
+export interface MyReviewsQuery extends PageQuery {
+    /** Only the reviews with this rating (1 to 5). */
+    rating?: number;
+}
+export type MyReviewPage = Page<MyReview>;
+/** What the store answers to writing a review: the review, in `data`. */
+export interface ReviewAnswer {
+    data: CustomerReview;
+}
+/** What it answers to removing one: the review that was removed (its `id` at least; the store sends the whole row). */
+export interface ReviewDeletedAnswer {
+    data: {
+        id: string;
+    } & Partial<CustomerReview>;
+}
+/** The `code`s of what the store refuses of a review. */
+export declare const REVIEW_ERROR_CODES: {
+    /** Only a customer whose address is verified can review. */
+    readonly emailNotVerified: "EMAIL_NOT_VERIFIED";
+    /** One review for each variant. */
+    readonly alreadyExists: "REVIEW_ALREADY_EXISTS";
+    /** A guest has to log in (from here: the store is not asked). */
+    readonly loginRequired: "LOGIN_REQUIRED";
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/reviews/types.js

@@ -0,0 +1,10 @@
+/** The `code`s of what the store refuses of a review. */
+export const REVIEW_ERROR_CODES = {
+    /** Only a customer whose address is verified can review. */
+    emailNotVerified: 'EMAIL_NOT_VERIFIED',
+    /** One review for each variant. */
+    alreadyExists: 'REVIEW_ALREADY_EXISTS',
+    /** A guest has to log in (from here: the store is not asked). */
+    loginRequired: 'LOGIN_REQUIRED',
+};
+//# sourceMappingURL=types.js.map

package/dist/shop/address-store.d.ts

@@ -0,0 +1,14 @@
+import { type AddressOptions } from './address.js';
+import type { ShopStore } from './store.js';
+export interface AddressPort {
+    /** The query string of the address now: `''` or `'?a=1&b=2'`. */
+    read(): string;
+    /** Puts this query string in the address (the page's path stays what it is) and adds a history entry, so "back" goes back to what it was. */
+    write(search: string): void;
+    /** Called when the address changed whoever changed it (a link, the back button, `write`). Returns what stops it. */
+    subscribe(listener: () => void): () => void;
+}
+export declare function createAddressShopStore(port: AddressPort, options?: AddressOptions & {
+    collectionId?: string;
+}): ShopStore;
+//# sourceMappingURL=address-store.d.ts.map

package/dist/shop/address-store.js

@@ -0,0 +1,28 @@
+import { canonicalJson } from '../canonical.js';
+import { applyShopQuery, queryToShopState } from './address.js';
+export function createAddressShopStore(port, options = {}) {
+    // The state is the SAME object while the address is the same text (what a framework compares to know that nothing changed)
+    let cache = null;
+    const getState = () => {
+        const search = port.read();
+        if (cache === null || cache.search !== search) {
+            const state = queryToShopState(search, options);
+            // Another part of the address changed (`utm_source`), not what is about the shop: the state is the same one
+            cache = { search, state: cache !== null && canonicalJson(cache.state) === canonicalJson(state) ? cache.state : state };
+        }
+        return cache.state;
+    };
+    return {
+        getState,
+        subscribe: (listener) => port.subscribe(listener),
+        set(next) {
+            const current = port.read();
+            const written = applyShopQuery(current, next, options);
+            // What the address would say of the shop is what it already says (a change that changes nothing, or only what an address cannot carry): no new entry in the history
+            if (canonicalJson(queryToShopState(written, options)) === canonicalJson(getState()))
+                return;
+            port.write(written);
+        },
+    };
+}
+//# sourceMappingURL=address-store.js.map

package/dist/shop/address.d.ts

@@ -0,0 +1,12 @@
+import { type ShopState } from './state.js';
+export interface AddressOptions {
+    /** The shop's own number per page: it is not written when it is this (and it is what an address with no `limit` means). */
+    limit?: number;
+}
+/** The query string (`?a=1&b=2`, or '' for none) of an address `search` with the choices of `state` in it: ours replaced, the others kept as they were, in their place. */
+export declare function applyShopQuery(search: string, state: ShopState, options?: AddressOptions): string;
+/** The state an address says. `collectionId` (the page's, not the address's) and the shop's own `limit` are what the address does not say; what it says over them wins. Needs no store's data: what a value means is for `toSearch`. */
+export declare function queryToShopState(search: string, options?: AddressOptions & {
+    collectionId?: string;
+}): ShopState;
+//# sourceMappingURL=address.d.ts.map

package/dist/shop/address.js

@@ -0,0 +1,95 @@
+import { plainNumber } from './range.js';
+import { DEFAULT_SHOP_LIMIT, emptyShopState } from './state.js';
+// What a customer chose, written in the ADDRESS of the page (`?q=tubo&r.<filter>=10..50&sort=price:asc&page=2`) and read back from it: so a search is a link, "back" goes back through the choices, and a
+// reload keeps them. Pure: it takes and gives the query string, and knows nothing of a router. The rules:
+//  - what is the default is not written (page 1, the shop's own limit, nothing chosen): an empty state is an empty query;
+//  - only OUR keys are touched: `utm_source`, `lang` and whatever else the address has stays exactly as it was;
+//  - an address typed by hand, or an old link, can say anything: what is not valid is ignored, never an error (and `toSearch` corrects what is left). The first of a repeated key counts;
+//  - the collection is not here: it is the PAGE (`/shop/<slug>`), and the page tells the state (`setCollection`);
+//  - the ids are the store's own (a filter's, a tag value's): long, but stable and not ambiguous (names are not unique and change with the language).
+// The keys: `q` the text · `ignore` 1/0 (searchIgnoresFilters) · `tags` tag value ids, with commas · `r.<filter id>` a range, `min..max`, either side may be empty (`..50`, `10..`) · `sort` `<field>:<asc|desc>`
+// (`price:asc`, `tag:<id>:desc`) · `page` · `limit`.
+const KEYS = ['q', 'ignore', 'tags', 'sort', 'page', 'limit'];
+const RANGE = 'r.';
+const FIELDS = new Set(['createdAt', 'updatedAt', 'alphabetical', 'price', 'match', 'availability']);
+const isOurs = (key) => KEYS.includes(key) || key.startsWith(RANGE);
+function boundText(bound) {
+    if (typeof bound === 'number')
+        return Number.isFinite(bound) ? plainNumber(bound) : '';
+    return typeof bound === 'string' ? bound.trim() : '';
+}
+/** The query string (`?a=1&b=2`, or '' for none) of an address `search` with the choices of `state` in it: ours replaced, the others kept as they were, in their place. */
+export function applyShopQuery(search, state, options = {}) {
+    const defaultLimit = options.limit ?? DEFAULT_SHOP_LIMIT;
+    const kept = new URLSearchParams(search);
+    for (const key of [...new Set([...kept.keys()])])
+        if (isOurs(key))
+            kept.delete(key);
+    const ours = new URLSearchParams();
+    if (typeof state.search === 'string' && state.search.trim() !== '')
+        ours.set('q', state.search);
+    if (typeof state.searchIgnoresFilters === 'boolean')
+        ours.set('ignore', state.searchIgnoresFilters ? '1' : '0');
+    const tags = [...new Set(state.tagValueIds)].filter((id) => typeof id === 'string' && id !== '' && !id.includes(','));
+    if (tags.length > 0)
+        ours.set('tags', tags.join(','));
+    for (const id of Object.keys(state.ranges).sort()) {
+        const range = state.ranges[id];
+        const min = boundText(range?.min), max = boundText(range?.max);
+        if (id !== '' && (min !== '' || max !== ''))
+            ours.set(`${RANGE}${id}`, `${min}..${max}`);
+    }
+    if (state.sortBy !== undefined && (state.sortDirection === 'asc' || state.sortDirection === 'desc'))
+        ours.set('sort', `${state.sortBy}:${state.sortDirection}`);
+    if (Number.isInteger(state.page) && state.page > 1)
+        ours.set('page', String(state.page));
+    if (Number.isInteger(state.limit) && state.limit !== defaultLimit && state.limit > 0)
+        ours.set('limit', String(state.limit));
+    // What is ours is written so that it can be read: `:` and `,` mean something to us and are safe in a query (what the address already had is not rewritten)
+    const text = [kept.toString(), ours.toString().replace(/%3A/gi, ':').replace(/%2C/gi, ',')].filter((part) => part !== '').join('&');
+    return text === '' ? '' : `?${text}`;
+}
+const wholeNumber = (text) => (text !== null && /^\d{1,9}$/.test(text) && Number(text) > 0 ? Number(text) : null);
+function parseSort(text) {
+    if (text === null)
+        return null;
+    const cut = text.lastIndexOf(':');
+    const field = text.slice(0, cut);
+    const direction = text.slice(cut + 1);
+    if (cut < 1 || (direction !== 'asc' && direction !== 'desc'))
+        return null;
+    const sorted = field.startsWith('tag:') ? field.length > 4 : field.startsWith('attribute:') ? field.length > 10 : FIELDS.has(field);
+    return sorted ? { sortBy: field, sortDirection: direction } : null;
+}
+/** The state an address says. `collectionId` (the page's, not the address's) and the shop's own `limit` are what the address does not say; what it says over them wins. Needs no store's data: what a value means is for `toSearch`. */
+export function queryToShopState(search, options = {}) {
+    const params = new URLSearchParams(search);
+    const state = emptyShopState({ limit: wholeNumber(params.get('limit')) ?? options.limit ?? DEFAULT_SHOP_LIMIT, collectionId: options.collectionId });
+    const text = params.get('q');
+    const ignore = params.get('ignore');
+    const tags = (params.get('tags') ?? '').split(',').filter((id) => id !== '');
+    const ranges = {};
+    for (const [key, value] of params) {
+        if (!key.startsWith(RANGE) || key.length === RANGE.length || key.slice(RANGE.length) in ranges)
+            continue;
+        const at = value.indexOf('..');
+        if (at < 0)
+            continue;
+        const min = value.slice(0, at).trim(), max = value.slice(at + 2).trim();
+        if (min === '' && max === '')
+            continue;
+        ranges[key.slice(RANGE.length)] = { ...(min === '' ? {} : { min }), ...(max === '' ? {} : { max }) };
+    }
+    const sort = parseSort(params.get('sort'));
+    const page = wholeNumber(params.get('page'));
+    return {
+        ...state,
+        ...(text !== null && text.trim() !== '' ? { search: text } : {}),
+        ...(ignore === '1' ? { searchIgnoresFilters: true } : ignore === '0' ? { searchIgnoresFilters: false } : {}),
+        tagValueIds: [...new Set(tags)],
+        ranges,
+        ...(sort ?? {}),
+        page: page ?? 1,
+    };
+}
+//# sourceMappingURL=address.js.map

package/dist/shop/index.d.ts

@@ -0,0 +1,16 @@
+export { DEFAULT_SHOP_LIMIT, clearFilters, clearSort, emptyShopState, setCollection, setLimit, setPage, setRange, setSearch, setSearchIgnoresFilters, setSort, toggleTagValue } from './state.js';
+export type { RangeBound, RangeValue, ShopState } from './state.js';
+export { rangeFilterId } from './range.js';
+export { sortOptionsOf, validSort } from './sort.js';
+export type { SortOption } from './sort.js';
+export { toSearch } from './to-search.js';
+export type { SearchContext } from './to-search.js';
+export { createShopStore, shopActions } from './store.js';
+export type { ShopActions, ShopStore } from './store.js';
+export { shopQuestion } from './question.js';
+export type { ShopQuestion } from './question.js';
+export { applyShopQuery, queryToShopState } from './address.js';
+export type { AddressOptions } from './address.js';
+export { createAddressShopStore } from './address-store.js';
+export type { AddressPort } from './address-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/shop/index.js

@@ -0,0 +1,9 @@
+export { DEFAULT_SHOP_LIMIT, clearFilters, clearSort, emptyShopState, setCollection, setLimit, setPage, setRange, setSearch, setSearchIgnoresFilters, setSort, toggleTagValue } from './state.js';
+export { rangeFilterId } from './range.js';
+export { sortOptionsOf, validSort } from './sort.js';
+export { toSearch } from './to-search.js';
+export { createShopStore, shopActions } from './store.js';
+export { shopQuestion } from './question.js';
+export { applyShopQuery, queryToShopState } from './address.js';
+export { createAddressShopStore } from './address-store.js';
+//# sourceMappingURL=index.js.map

package/dist/shop/question.d.ts

@@ -0,0 +1,15 @@
+import type { CachedCatalog, Resource } from '../catalog/cached.js';
+import type { ProductPage, ProductSearch, StoreData } from '../catalog/types.js';
+import type { ShopState } from './state.js';
+import { type SearchContext } from './to-search.js';
+/** What the shop is asking the catalog right now: the question, and the cache's view of it (a `Resource`, which is what a framework binds to). */
+export interface ShopQuestion {
+    question: ProductSearch;
+    resource: Resource<ProductPage>;
+}
+/**
+ * The state of the shop made into a question of the cached catalog. It needs the store's data (its tags, collections and filters say what a state means), so until they are there there is no question:
+ * `null`. ONE place does this, so an adapter for another framework only binds what it returns.
+ */
+export declare function shopQuestion(catalog: Pick<CachedCatalog, 'resource'>, storeData: StoreData | null | undefined, state: ShopState, context: SearchContext): ShopQuestion | null;
+//# sourceMappingURL=question.d.ts.map

package/dist/shop/question.js

@@ -0,0 +1,12 @@
+import { toSearch } from './to-search.js';
+/**
+ * The state of the shop made into a question of the cached catalog. It needs the store's data (its tags, collections and filters say what a state means), so until they are there there is no question:
+ * `null`. ONE place does this, so an adapter for another framework only binds what it returns.
+ */
+export function shopQuestion(catalog, storeData, state, context) {
+    if (!storeData)
+        return null;
+    const question = toSearch(state, storeData, context);
+    return { question, resource: catalog.resource.products.search(question) };
+}
+//# sourceMappingURL=question.js.map

package/dist/shop/range.d.ts

@@ -0,0 +1,7 @@
+import type { StoreFilter } from '../catalog/types.js';
+import type { RangeValue } from './state.js';
+/** A number written plainly (no exponent): the catalog reads digits (and so does an address). */
+export declare function plainNumber(n: number): string;
+/** The text of the range of `filter` the customer chose (`<id>[<min>;<max>]`), or null when there is nothing to send (no ends). A minimum above the maximum is turned round (the customer meant the two ends); equal ones are a range. */
+export declare function rangeFilterId(filter: Pick<StoreFilter, 'id' | 'type'>, range: RangeValue): string | null;
+//# sourceMappingURL=range.d.ts.map

package/dist/shop/range.js

@@ -0,0 +1,38 @@
+const isoDate = /^(\d{4})-(\d{2})-(\d{2})$/;
+/** A number written plainly (no exponent): the catalog reads digits (and so does an address). */
+export function plainNumber(n) {
+    return n.toLocaleString('en-US', { useGrouping: false, maximumFractionDigits: 20 }).replace(/^-0$/, '0');
+}
+function numberBound(bound) {
+    const n = typeof bound === 'number' ? bound : typeof bound === 'string' && bound.trim() !== '' ? Number(bound.trim()) : Number.NaN;
+    // Beyond what a number can hold exactly it is no price, and writing it would need an exponent
+    return Number.isFinite(n) && Math.abs(n) <= Number.MAX_SAFE_INTEGER ? { text: plainNumber(n), value: n } : null;
+}
+function dateBound(bound) {
+    if (typeof bound === 'number')
+        return Number.isSafeInteger(bound) ? { text: String(bound), value: bound } : null;
+    if (typeof bound !== 'string')
+        return null;
+    const text = bound.trim();
+    const parts = isoDate.exec(text);
+    if (parts) {
+        const [year, month, day] = [Number(parts[1]), Number(parts[2]), Number(parts[3])];
+        const at = Date.UTC(year, month - 1, day);
+        const real = new Date(at);
+        // 2020-02-31 is not a day (the catalog would make it a different one)
+        return real.getUTCFullYear() === year && real.getUTCMonth() === month - 1 && real.getUTCDate() === day ? { text, value: at } : null;
+    }
+    return /^-?\d+$/.test(text) && Number.isSafeInteger(Number(text)) ? { text: String(Number(text)), value: Number(text) } : null;
+}
+/** The text of the range of `filter` the customer chose (`<id>[<min>;<max>]`), or null when there is nothing to send (no ends). A minimum above the maximum is turned round (the customer meant the two ends); equal ones are a range. */
+export function rangeFilterId(filter, range) {
+    const read = filter.type === 'date' ? dateBound : numberBound;
+    let min = read(range.min);
+    let max = read(range.max);
+    if (!min && !max)
+        return null;
+    if (min && max && min.value > max.value)
+        [min, max] = [max, min];
+    return `${filter.id}[${min?.text ?? ''};${max?.text ?? ''}]`;
+}
+//# sourceMappingURL=range.js.map