@webround/commerce 0.0.0-stage → 0.3.0

package/dist/shop/sort.d.ts

@@ -0,0 +1,19 @@
+import type { ProductSortField, SortDirection, StoreData } from '../catalog/types.js';
+export interface SortOption {
+    sortBy: ProductSortField;
+    /** Where the order comes from: one every store has (`field`), or a tag or an attribute of this store (then `name` is what it is called). */
+    source: 'field' | 'tag' | 'attribute';
+    /** The tag's or attribute's label (or name): what the control says. For a `field` the interface says it in its own words. */
+    name?: string;
+}
+/** What can be sorted by now. Every option goes both ways (`asc`, `desc`). */
+export declare function sortOptionsOf(store: Pick<StoreData, 'tags' | 'attributes'>): SortOption[];
+/** The order a customer chose, if it is still one that is offered and has its direction; otherwise none (the catalog's own order). */
+export declare function validSort(store: Pick<StoreData, 'tags' | 'attributes'>, chosen: {
+    sortBy?: ProductSortField;
+    sortDirection?: SortDirection;
+}): {
+    sortBy: ProductSortField;
+    sortDirection: SortDirection;
+} | null;
+//# sourceMappingURL=sort.d.ts.map

package/dist/shop/sort.js

@@ -0,0 +1,18 @@
+// "match" is the best answer to the text; with no text the catalog orders by creation, newest first, so it is always an order
+const FIELDS = ['match', 'createdAt', 'updatedAt', 'alphabetical', 'price', 'availability'];
+/** What can be sorted by now. Every option goes both ways (`asc`, `desc`). */
+export function sortOptionsOf(store) {
+    return [
+        ...FIELDS.map((sortBy) => ({ sortBy, source: 'field' })),
+        ...store.tags.filter((tag) => tag.sortable).map((tag) => ({ sortBy: `tag:${tag.id}`, source: 'tag', name: tag.label ?? tag.name })),
+        ...store.attributes.filter((attribute) => attribute.sortable).map((attribute) => ({ sortBy: `attribute:${attribute.id}`, source: 'attribute', name: attribute.label ?? attribute.name })),
+    ];
+}
+/** The order a customer chose, if it is still one that is offered and has its direction; otherwise none (the catalog's own order). */
+export function validSort(store, chosen) {
+    const { sortBy, sortDirection } = chosen;
+    if (sortBy === undefined || (sortDirection !== 'asc' && sortDirection !== 'desc'))
+        return null;
+    return sortOptionsOf(store).some((option) => option.sortBy === sortBy) ? { sortBy, sortDirection } : null;
+}
+//# sourceMappingURL=sort.js.map

package/dist/shop/state.d.ts

@@ -0,0 +1,47 @@
+import type { ProductSortField, SortDirection } from '../catalog/types.js';
+/** One end of a range: a number (a price, a number attribute), or for a date `YYYY-MM-DD` or a number of milliseconds. A text of digits is read as a number. Empty or missing: no limit on that side. */
+export type RangeBound = number | string | null | undefined;
+export interface RangeValue {
+    min?: RangeBound;
+    max?: RangeBound;
+}
+export interface ShopState {
+    /** The collection the customer is in: its filters apply (see `StoreCollection.filterIds`). */
+    collectionId?: string;
+    /** What was typed in the search box, as it was typed. */
+    search?: string;
+    /** With a text, search ALL the products and not only the ones the filters leave (the catalog's `searchIgnoresFilters`). Left unsaid, the catalog decides. */
+    searchIgnoresFilters?: boolean;
+    /** The tag values chosen: values of one tag are alternatives, values of different tags all have to be there. */
+    tagValueIds: readonly string[];
+    /** The range chosen for each range filter, by the filter's id. One range per filter. */
+    ranges: Readonly<Record<string, RangeValue>>;
+    sortBy?: ProductSortField;
+    sortDirection?: SortDirection;
+    page: number;
+    limit: number;
+}
+/** How many products a page has when nobody said: the shop's own choice (the catalog's own default is not repeated here). */
+export declare const DEFAULT_SHOP_LIMIT = 12;
+export declare function emptyShopState(over?: {
+    limit?: number;
+    collectionId?: string;
+}): ShopState;
+/** `undefined` takes the collection away (the whole store). */
+export declare function setCollection(state: ShopState, collectionId: string | undefined): ShopState;
+export declare function setSearch(state: ShopState, search: string | undefined): ShopState;
+export declare function setSearchIgnoresFilters(state: ShopState, ignores: boolean | undefined): ShopState;
+/** Chooses a tag value, or takes it away if it was chosen. */
+export declare function toggleTagValue(state: ShopState, tagValueId: string): ShopState;
+/** The range of a filter. `null`, `undefined` or one with no ends takes it away. */
+export declare function setRange(state: ShopState, filterId: string, range: RangeValue | null | undefined): ShopState;
+/** Takes away every filter the customer chose (not the collection, the text or the order). */
+export declare function clearFilters(state: ShopState): ShopState;
+/** The order and its direction go together: a sorting with no direction is the catalog's to decide (descending), and a rule never leaves that unsaid. */
+export declare function setSort(state: ShopState, sortBy: ProductSortField, sortDirection: SortDirection): ShopState;
+export declare function clearSort(state: ShopState): ShopState;
+/** The only change that does not go back to page 1. What is not a page (0, 1.5, NaN) is corrected when the question is made. */
+export declare function setPage(state: ShopState, page: number): ShopState;
+/** How many per page: the customer is put back on page 1, for the page they were on is not the same any more. */
+export declare function setLimit(state: ShopState, limit: number): ShopState;
+//# sourceMappingURL=state.d.ts.map

package/dist/shop/state.js

@@ -0,0 +1,51 @@
+/** How many products a page has when nobody said: the shop's own choice (the catalog's own default is not repeated here). */
+export const DEFAULT_SHOP_LIMIT = 12;
+export function emptyShopState(over = {}) {
+    return { tagValueIds: [], ranges: {}, page: 1, limit: over.limit ?? DEFAULT_SHOP_LIMIT, ...(over.collectionId === undefined ? {} : { collectionId: over.collectionId }) };
+}
+/** A change of what is looked for: the same state with it, and back on the first page. */
+const looking = (state, changes) => ({ ...state, ...changes, page: 1 });
+/** `undefined` takes the collection away (the whole store). */
+export function setCollection(state, collectionId) {
+    const { collectionId: _gone, ...rest } = state;
+    return looking(rest, collectionId === undefined ? {} : { collectionId });
+}
+export function setSearch(state, search) {
+    const { search: _gone, ...rest } = state;
+    return looking(rest, search === undefined || search === '' ? {} : { search });
+}
+export function setSearchIgnoresFilters(state, ignores) {
+    const { searchIgnoresFilters: _gone, ...rest } = state;
+    return looking(rest, ignores === undefined ? {} : { searchIgnoresFilters: ignores });
+}
+/** Chooses a tag value, or takes it away if it was chosen. */
+export function toggleTagValue(state, tagValueId) {
+    return looking(state, { tagValueIds: state.tagValueIds.includes(tagValueId) ? state.tagValueIds.filter((id) => id !== tagValueId) : [...state.tagValueIds, tagValueId] });
+}
+/** The range of a filter. `null`, `undefined` or one with no ends takes it away. */
+export function setRange(state, filterId, range) {
+    const { [filterId]: _gone, ...others } = state.ranges;
+    const open = (bound) => bound === null || bound === undefined || bound === '';
+    return looking(state, { ranges: !range || (open(range.min) && open(range.max)) ? others : { ...others, [filterId]: { ...range } } });
+}
+/** Takes away every filter the customer chose (not the collection, the text or the order). */
+export function clearFilters(state) {
+    return looking(state, { tagValueIds: [], ranges: {} });
+}
+/** The order and its direction go together: a sorting with no direction is the catalog's to decide (descending), and a rule never leaves that unsaid. */
+export function setSort(state, sortBy, sortDirection) {
+    return looking(state, { sortBy, sortDirection });
+}
+export function clearSort(state) {
+    const { sortBy: _by, sortDirection: _direction, ...rest } = state;
+    return looking(rest, {});
+}
+/** The only change that does not go back to page 1. What is not a page (0, 1.5, NaN) is corrected when the question is made. */
+export function setPage(state, page) {
+    return { ...state, page };
+}
+/** How many per page: the customer is put back on page 1, for the page they were on is not the same any more. */
+export function setLimit(state, limit) {
+    return looking(state, { limit });
+}
+//# sourceMappingURL=state.js.map

package/dist/shop/store.d.ts

@@ -0,0 +1,26 @@
+import type { ProductSortField, SortDirection } from '../catalog/types.js';
+import { type RangeValue, type ShopState } from './state.js';
+export interface ShopStore {
+    getState(): ShopState;
+    /** Called whenever the state changed, once for each change. Returns what stops it. */
+    subscribe(listener: () => void): () => void;
+    /** Replaces the state (a change the customer made, or the address that changed under it). */
+    set(next: ShopState): void;
+}
+/** The state in memory, for as long as the store lives. The state is the SAME object until something really changes: a change that leaves it as it was (the same range again) tells nobody. */
+export declare function createShopStore(initial?: ShopState): ShopStore;
+/** What a page's controls call: the changes of `state.ts`, applied to a store. The same functions, not others: what a change means is written once. */
+export interface ShopActions {
+    setCollection(collectionId: string | undefined): void;
+    setSearch(search: string | undefined): void;
+    setSearchIgnoresFilters(ignores: boolean | undefined): void;
+    toggleTagValue(tagValueId: string): void;
+    setRange(filterId: string, range: RangeValue | null | undefined): void;
+    clearFilters(): void;
+    setSort(sortBy: ProductSortField, sortDirection: SortDirection): void;
+    clearSort(): void;
+    setPage(page: number): void;
+    setLimit(limit: number): void;
+}
+export declare function shopActions(store: ShopStore): ShopActions;
+//# sourceMappingURL=store.d.ts.map

package/dist/shop/store.js

@@ -0,0 +1,47 @@
+import { canonicalJson } from '../canonical.js';
+import { clearFilters, clearSort, emptyShopState, setCollection, setLimit, setPage, setRange, setSearch, setSearchIgnoresFilters, setSort, toggleTagValue, } from './state.js';
+/** The state in memory, for as long as the store lives. The state is the SAME object until something really changes: a change that leaves it as it was (the same range again) tells nobody. */
+export function createShopStore(initial = emptyShopState()) {
+    let state = initial;
+    let key = canonicalJson(state);
+    const listeners = new Set();
+    return {
+        getState: () => state,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => { listeners.delete(listener); };
+        },
+        set(next) {
+            const nextKey = canonicalJson(next);
+            if (nextKey === key)
+                return;
+            state = next;
+            key = nextKey;
+            // A listener that throws changes nothing here: it is thrown where nobody is waiting on it, so it is seen
+            for (const listener of [...listeners]) {
+                try {
+                    listener();
+                }
+                catch (error) {
+                    setTimeout(() => { throw error; }, 0);
+                }
+            }
+        },
+    };
+}
+export function shopActions(store) {
+    const apply = (change) => store.set(change(store.getState()));
+    return {
+        setCollection: (collectionId) => apply((s) => setCollection(s, collectionId)),
+        setSearch: (search) => apply((s) => setSearch(s, search)),
+        setSearchIgnoresFilters: (ignores) => apply((s) => setSearchIgnoresFilters(s, ignores)),
+        toggleTagValue: (tagValueId) => apply((s) => toggleTagValue(s, tagValueId)),
+        setRange: (filterId, range) => apply((s) => setRange(s, filterId, range)),
+        clearFilters: () => apply(clearFilters),
+        setSort: (sortBy, sortDirection) => apply((s) => setSort(s, sortBy, sortDirection)),
+        clearSort: () => apply(clearSort),
+        setPage: (page) => apply((s) => setPage(s, page)),
+        setLimit: (limit) => apply((s) => setLimit(s, limit)),
+    };
+}
+//# sourceMappingURL=store.js.map

package/dist/shop/to-search.d.ts

@@ -0,0 +1,14 @@
+import type { ProductLoad, ProductSearch, StoreData } from '../catalog/types.js';
+import { type ShopState } from './state.js';
+export interface SearchContext {
+    /** Prices come in this currency. */
+    currencyCode: string;
+    langCode?: string;
+    cadence?: string;
+    /** What the products are loaded with: the caller's choice (`include*`, `includeNestedVariants`). */
+    load?: ProductLoad & {
+        includeNestedVariants?: boolean;
+    };
+}
+export declare function toSearch(state: ShopState, store: Pick<StoreData, 'tags' | 'attributes' | 'collections' | 'filters'>, context: SearchContext): ProductSearch;
+//# sourceMappingURL=to-search.d.ts.map

package/dist/shop/to-search.js

@@ -0,0 +1,53 @@
+import { rangeFilterId } from './range.js';
+import { validSort } from './sort.js';
+import { DEFAULT_SHOP_LIMIT } from './state.js';
+// What is not a number is not sent as one (JSON would make it `null`); how big a page may be, how far a page may go and how long a text may be is the catalog's to say: its 400 is what a question that goes over gets
+const whole = (n, fallback) => (Number.isFinite(n) ? Math.trunc(n) : fallback);
+function findCollection(collections, id) {
+    for (const collection of collections) {
+        if (collection.id === id)
+            return collection;
+        const inside = findCollection(collection.children, id);
+        if (inside)
+            return inside;
+    }
+    return undefined;
+}
+export function toSearch(state, store, context) {
+    // The page and the limit are whole numbers: what they may be is the catalog's to say
+    const limit = whole(state.limit, DEFAULT_SHOP_LIMIT);
+    const page = whole(state.page, 1);
+    // A state can come from outside the program (an address, a stored page): what is not of the type it should be is taken for nothing, so this never throws
+    const ranges = typeof state.ranges === 'object' && state.ranges !== null ? state.ranges : {};
+    const tagValueIds = Array.isArray(state.tagValueIds) ? state.tagValueIds.filter((id) => typeof id === 'string') : [];
+    // A text of spaces is no text, and the catalog refuses an empty one
+    const text = typeof state.search === 'string' ? state.search.trim() : '';
+    const hasSearch = text !== '';
+    // The filters: the ones of the collection (as they are), and the range the customer chose for each of the store's range filters. Ids are the store's own, never changed; one the store does not have is left out
+    const fromCollection = typeof state.collectionId === 'string' ? findCollection(store.collections, state.collectionId)?.filterIds ?? [] : [];
+    const fromRanges = store.filters.flatMap((filter) => {
+        const range = ranges[filter.id];
+        const written = typeof range === 'object' && range !== null ? rangeFilterId(filter, range) : null;
+        return written === null ? [] : [written];
+    });
+    const filterIds = [...new Set([...fromCollection, ...fromRanges])];
+    // Tag values the store has (a stale one, or one that is not an id, would be refused or do nothing)
+    const known = new Set(store.tags.flatMap((tag) => tag.values.map((value) => value.id)));
+    const knownTagValueIds = [...new Set(tagValueIds)].filter((id) => known.has(id));
+    const sort = validSort(store, state);
+    return {
+        currencyCode: context.currencyCode,
+        page,
+        limit,
+        ...(context.langCode === undefined ? {} : { langCode: context.langCode }),
+        ...(context.cadence === undefined ? {} : { cadence: context.cadence }),
+        ...(filterIds.length > 0 ? { filterIds } : {}),
+        ...(knownTagValueIds.length > 0 ? { tagValueIds: knownTagValueIds } : {}),
+        ...(hasSearch ? { search: text } : {}),
+        // It means something only with a text
+        ...(hasSearch && typeof state.searchIgnoresFilters === 'boolean' ? { searchIgnoresFilters: state.searchIgnoresFilters } : {}),
+        ...(sort ?? {}),
+        ...(context.load ?? {}),
+    };
+}
+//# sourceMappingURL=to-search.js.map

package/dist/store-kit.d.ts

@@ -0,0 +1,39 @@
+export interface StateHolder<S> {
+    get(): S;
+    /** Changes some of the state. A change that leaves it as it was tells nobody. A listener that throws changes nothing here: it is thrown where nobody is waiting on it, so it is seen. */
+    set(next: Partial<S>): void;
+    subscribe(listener: () => void): () => void;
+}
+export declare function createStateHolder<S>(initial: S): StateHolder<S>;
+export interface SerialQueue {
+    /** Runs `task` after the ones before it, whatever became of them (a task that fails does not stop the ones after it). What it gives or throws is what comes back. */
+    run<T>(task: () => Promise<T>): Promise<T>;
+    /** How many tasks there are, the one running included. */
+    pending(): number;
+}
+/** Actions one at a time, in the order they were made. `onBusy` is told when the queue goes from empty to not empty and back. */
+export declare function createSerialQueue(onBusy?: (busy: boolean) => void): SerialQueue;
+/** Whose data a store holds: nobody known yet, a guest's, or a customer's. */
+export type Owner = 'unknown' | 'guest' | 'customer';
+export interface AuthFollowing {
+    /** Asks the auth store to find out who is logged in, and follows it from now on. Once; the same promise after. */
+    start(): Promise<void>;
+    /** Stops following. */
+    stop(): void;
+}
+/**
+ * What a store that has a guest's data and a customer's does with the auth store: logged in is a customer, logged out is a guest, and signing in or a code being asked changes nothing for a guest. `owner`
+ * says who the store holds now; `toGuest` and `toCustomer` are told when it changes hands.
+ */
+export declare function followAuth(auth: {
+    getState(): {
+        status: string;
+    };
+    subscribe(listener: () => void): () => void;
+    restore(): Promise<void>;
+}, owner: {
+    current(): Owner;
+    toGuest(): void;
+    toCustomer(): void;
+}): AuthFollowing;
+//# sourceMappingURL=store-kit.d.ts.map

package/dist/store-kit.js

@@ -0,0 +1,81 @@
+import { canonicalJson } from './canonical.js';
+export function createStateHolder(initial) {
+    let state = initial;
+    let key = canonicalJson(state);
+    const listeners = new Set();
+    return {
+        get: () => state,
+        set(next) {
+            const merged = { ...state, ...next };
+            const mergedKey = canonicalJson(merged);
+            if (mergedKey === key)
+                return;
+            state = merged;
+            key = mergedKey;
+            for (const listener of [...listeners]) {
+                try {
+                    listener();
+                }
+                catch (error) {
+                    setTimeout(() => { throw error; }, 0);
+                }
+            }
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => { listeners.delete(listener); };
+        },
+    };
+}
+/** Actions one at a time, in the order they were made. `onBusy` is told when the queue goes from empty to not empty and back. */
+export function createSerialQueue(onBusy) {
+    let chain = Promise.resolve();
+    let pending = 0;
+    return {
+        pending: () => pending,
+        run(task) {
+            if (pending++ === 0)
+                onBusy?.(true);
+            const result = chain.then(task);
+            chain = result.then(() => undefined, () => undefined);
+            const done = () => { if (--pending === 0)
+                onBusy?.(false); };
+            result.then(done, done);
+            return result;
+        },
+    };
+}
+/**
+ * What a store that has a guest's data and a customer's does with the auth store: logged in is a customer, logged out is a guest, and signing in or a code being asked changes nothing for a guest. `owner`
+ * says who the store holds now; `toGuest` and `toCustomer` are told when it changes hands.
+ */
+export function followAuth(auth, owner) {
+    let started = null;
+    let stopFollowing = null;
+    function follow() {
+        const { status } = auth.getState();
+        if (status === 'signedIn') {
+            if (owner.current() !== 'customer')
+                owner.toCustomer();
+            return;
+        }
+        if (status === 'signedOut' || (owner.current() === 'unknown' && (status === 'signingIn' || status === 'challenge'))) {
+            if (owner.current() !== 'guest')
+                owner.toGuest();
+        }
+    }
+    return {
+        start() {
+            if (started)
+                return started;
+            stopFollowing = auth.subscribe(follow);
+            started = auth.restore().then(follow, follow);
+            return started;
+        },
+        stop() {
+            stopFollowing?.();
+            stopFollowing = null;
+        },
+    };
+}
+//# sourceMappingURL=store-kit.js.map

package/dist/wishlist/api.d.ts

@@ -0,0 +1,12 @@
+import type { HttpClient } from '../http.js';
+import type { CallOptions } from '../catalog/types.js';
+import type { AccessTokenOptions } from '../auth/api.js';
+import type { WishlistList, WishlistToggleAnswer } from './types.js';
+export interface WishlistApi {
+    /** `GET /store-customer-wishlists`: the wished variants, each with its product. */
+    list(options?: CallOptions & AccessTokenOptions): Promise<WishlistList>;
+    /** `POST /store-customer-wishlists`: the switch. A variant that is not wished becomes wished; one that is, is removed. */
+    toggle(variantId: string, options?: CallOptions & AccessTokenOptions): Promise<WishlistToggleAnswer>;
+}
+export declare function createWishlistApi(http: HttpClient): WishlistApi;
+//# sourceMappingURL=api.d.ts.map

package/dist/wishlist/api.js

@@ -0,0 +1,10 @@
+// The calls of commerce-core that are about a customer's wishlist (`/store-customer-wishlists`), each asking one thing and giving back what the store answers, unchanged. Both need the JWT of the customer. A store can turn the
+// wishlist off (403 "Wishlist is disabled for this store") and keeps a limited number of items for each customer (50 by default: past it, a 429 `dataLimitOf` knows).
+const bearer = (options) => (options?.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : {});
+export function createWishlistApi(http) {
+    return {
+        list: (options) => http.request({ path: '/store-customer-wishlists', headers: bearer(options), signal: options?.signal }),
+        toggle: (variantId, options) => http.request({ method: 'POST', path: '/store-customer-wishlists', body: { variantId }, headers: bearer(options), signal: options?.signal }),
+    };
+}
+//# sourceMappingURL=api.js.map

package/dist/wishlist/index.d.ts

@@ -0,0 +1,7 @@
+export { createWishlistApi } from './api.js';
+export type { WishlistApi } from './api.js';
+export { createWishlist, isInWishlist } from './wishlist.js';
+export type { Wishlist, WishlistOptions, WishlistState } from './wishlist.js';
+export { WISHLIST_ERROR_CODES } from './types.js';
+export type { WishlistAsset, WishlistItem, WishlistList, WishlistToggleAnswer, WishlistVariant } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/wishlist/index.js

@@ -0,0 +1,4 @@
+export { createWishlistApi } from './api.js';
+export { createWishlist, isInWishlist } from './wishlist.js';
+export { WISHLIST_ERROR_CODES } from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/wishlist/types.d.ts

@@ -0,0 +1,30 @@
+export interface WishlistAsset {
+    url: string;
+}
+export interface WishlistVariant {
+    id: string;
+    name: string;
+    assets?: WishlistAsset[];
+}
+/** One wished variant, with its product: the variant is in `product.variants`. */
+export interface WishlistItem {
+    product: {
+        id: string;
+        variants: WishlistVariant[];
+    };
+}
+export interface WishlistList {
+    data: WishlistItem[];
+    total: number;
+}
+/** What the switch did: `wasAdded` says which way it went; `item` is the one that was added. */
+export interface WishlistToggleAnswer {
+    success: boolean;
+    wasAdded: boolean;
+    item?: WishlistItem;
+}
+/** The `code` of the refusal a guest gets (from here: a guest has no wishlist). */
+export declare const WISHLIST_ERROR_CODES: {
+    readonly loginRequired: "LOGIN_REQUIRED";
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/wishlist/types.js

@@ -0,0 +1,4 @@
+// What the wishlist calls of commerce-core take and give, as the store says it. A customer keeps variants they want to come back to; there is one call that adds or removes (a switch). A guest has none: it is the customer's.
+/** The `code` of the refusal a guest gets (from here: a guest has no wishlist). */
+export const WISHLIST_ERROR_CODES = { loginRequired: 'LOGIN_REQUIRED' };
+//# sourceMappingURL=types.js.map

package/dist/wishlist/wishlist.d.ts

@@ -0,0 +1,45 @@
+import { CommerceError } from '../errors.js';
+import type { AuthStore } from '../auth/store.js';
+import { type Owner } from '../store-kit.js';
+import type { WishlistApi } from './api.js';
+import { type WishlistItem } from './types.js';
+export interface WishlistState {
+    /** Whose wishlist this is. `unknown` until it is known whether a customer is logged in; a guest's is empty. */
+    owner: Owner;
+    items: WishlistItem[];
+    /** The variants that are in it: what a heart on a product asks. */
+    variantIds: string[];
+    count: number;
+    /** The customer's list was read. */
+    loaded: boolean;
+    /** `false` once the store said it has the wishlist turned off (403); `null` while that is not known (nothing says it before asking). */
+    enabled: boolean | null;
+    /** A switch or a read is under way. */
+    busy: boolean;
+    /** What stopped the list from being read, without being a switch's own failure (those throw): it goes when it works again. */
+    error: CommerceError | null;
+}
+export interface Wishlist {
+    getState(): WishlistState;
+    subscribe(listener: () => void): () => void;
+    /** Starts following who is logged in (asks the auth store to find out) and reads the customer's wishlist. Once. */
+    start(): Promise<void>;
+    /**
+     * The switch: adds a variant that is not in the wishlist, removes one that is, and says which. Throws what the store refuses (the wishlist turned off: 403; over what it allows: 429, `dataLimitOf`; a variant that is
+     * not the store's) and, for a guest, `LOGIN_REQUIRED`. What is shown goes back to what the store holds.
+     */
+    toggle(variantId: string): Promise<{
+        wasAdded: boolean;
+    }>;
+    /** Reads the customer's wishlist again. */
+    refresh(): Promise<void>;
+    dispose(): void;
+}
+export interface WishlistOptions {
+    api: WishlistApi;
+    auth: Pick<AuthStore, 'getState' | 'subscribe' | 'restore'>;
+}
+export declare function createWishlist(options: WishlistOptions): Wishlist;
+/** Whether a variant is in the wishlist (what a heart asks). */
+export declare const isInWishlist: (state: Pick<WishlistState, "variantIds">, variantId: string) => boolean;
+//# sourceMappingURL=wishlist.d.ts.map

package/dist/wishlist/wishlist.js

@@ -0,0 +1,84 @@
+import { CommerceError, toCommerceError } from '../errors.js';
+import { createSerialQueue, createStateHolder, followAuth } from '../store-kit.js';
+import { WISHLIST_ERROR_CODES } from './types.js';
+const idsOf = (items) => items.flatMap((i) => i.product.variants.map((v) => v.id));
+/** Whether the store said the wishlist is off (its 403): a refusal that is not about the customer. */
+const isDisabled = (error) => error.status === 403 && /disabled/i.test(error.message);
+export function createWishlist(options) {
+    const { api, auth } = options;
+    const holder = createStateHolder({ owner: 'unknown', items: [], variantIds: [], count: 0, loaded: false, enabled: null, busy: false, error: null });
+    const set = holder.set;
+    const queue = createSerialQueue((busy) => set({ busy }));
+    // Counts the times the wishlist changed hands: an answer that comes after that is about a wishlist that is not this one any more
+    let epoch = 0;
+    async function loadCustomer() {
+        const mine = epoch;
+        try {
+            const list = await api.list();
+            if (epoch !== mine)
+                return;
+            set({ items: list.data, variantIds: idsOf(list.data), count: list.data.length, loaded: true, enabled: true, error: null });
+        }
+        catch (error) {
+            if (epoch !== mine)
+                return;
+            const failure = toCommerceError(error);
+            set(isDisabled(failure) ? { items: [], variantIds: [], count: 0, loaded: true, enabled: false, error: null } : { error: failure });
+        }
+    }
+    function toGuest() {
+        epoch++;
+        set({ owner: 'guest', items: [], variantIds: [], count: 0, loaded: true, error: null });
+    }
+    function toCustomer() {
+        epoch++;
+        set({ owner: 'customer', items: [], variantIds: [], count: 0, loaded: false, error: null });
+        void queue.run(loadCustomer);
+    }
+    const following = followAuth(auth, { current: () => holder.get().owner, toGuest, toCustomer });
+    return {
+        getState: holder.get,
+        subscribe: holder.subscribe,
+        start: () => following.start(),
+        async toggle(variantId) {
+            if (holder.get().owner === 'unknown')
+                await following.start();
+            if (holder.get().owner !== 'customer')
+                throw new CommerceError({ kind: 'http', status: 401, code: WISHLIST_ERROR_CODES.loginRequired, message: 'Log in to use the wishlist.' });
+            const mine = epoch;
+            // What a heart shows changes at once: the store settles it
+            const before = holder.get().variantIds;
+            const next = before.includes(variantId) ? before.filter((id) => id !== variantId) : [...before, variantId];
+            set({ variantIds: next, count: next.length });
+            return queue.run(async () => {
+                try {
+                    const answer = await api.toggle(variantId);
+                    return { wasAdded: answer.wasAdded };
+                }
+                catch (error) {
+                    const failure = toCommerceError(error);
+                    if (epoch === mine) {
+                        // What was shown at once was not so: it goes back now, whether or not the read that follows can be made
+                        set(isDisabled(failure) ? { variantIds: before, count: before.length, enabled: false } : { variantIds: before, count: before.length });
+                    }
+                    throw failure;
+                }
+                finally {
+                    // What is shown is what the store holds, a refusal included
+                    if (epoch === mine && queue.pending() === 1)
+                        await loadCustomer();
+                }
+            });
+        },
+        async refresh() {
+            if (holder.get().owner === 'unknown')
+                await following.start();
+            if (holder.get().owner === 'customer')
+                await queue.run(loadCustomer);
+        },
+        dispose: following.stop,
+    };
+}
+/** Whether a variant is in the wishlist (what a heart asks). */
+export const isInWishlist = (state, variantId) => state.variantIds.includes(variantId);
+//# sourceMappingURL=wishlist.js.map