@webround/commerce 0.0.0-stage → 0.3.0

package/dist/cart/api.d.ts

@@ -0,0 +1,25 @@
+import type { HttpClient } from '../http.js';
+import type { CallOptions } from '../catalog/types.js';
+import type { AccessTokenOptions } from '../auth/api.js';
+import type { Cart, CartItemAction, CartLineInput, CartMergeAnswer, CartTotalInput, GetCartInput, MergeCartInput, UpdateCartItemInput, VerifyPromotionsInput, VerifyPromotionsAnswer } from './types.js';
+export interface CartApi {
+    /** `GET /cart` (needs the JWT): the customer's cart, priced for the store's country and the language asked. */
+    get(input?: GetCartInput, options?: CallOptions & AccessTokenOptions): Promise<Cart>;
+    /**
+     * `POST /cart` (needs the JWT): adds a line. A variant that is already there is ADDED TO (not replaced; 10000 at most). The answer says what happened, not what the cart is now: ask for it with `get`.
+     * Refused with `CART_LIMIT_REACHED` (99 different variants) and `CART_CURRENCY_MISMATCH` (the cart has one currency and one cadence).
+     */
+    addItem(input: CartLineInput, options?: CallOptions & AccessTokenOptions): Promise<CartItemAction>;
+    /** `PATCH /cart/:id` (needs the JWT): the quantity of a line becomes this one (1 to 10000). `id` is the line's own (`CartItem.id`). */
+    updateItem(id: string, input: UpdateCartItemInput, options?: CallOptions & AccessTokenOptions): Promise<CartItemAction>;
+    /** `DELETE /cart/:id` (needs the JWT). */
+    removeItem(id: string, options?: CallOptions & AccessTokenOptions): Promise<CartItemAction>;
+    /** `POST /cart/merge` (needs the JWT): the lines of a guest's cart go into the customer's (up to 100 lines; 99 different variants in all). */
+    merge(input: MergeCartInput, options?: CallOptions & AccessTokenOptions): Promise<CartMergeAnswer>;
+    /** `POST /cart/total` (with or without the JWT): the cart these lines make, priced. For a guest, whose lines are in the page. */
+    total(input: CartTotalInput, options?: CallOptions & AccessTokenOptions): Promise<Cart>;
+    /** `POST /cart/promotion` (with or without the JWT): whether these codes can be used for this cart. */
+    verifyPromotions(input: VerifyPromotionsInput, options?: CallOptions & AccessTokenOptions): Promise<VerifyPromotionsAnswer>;
+}
+export declare function createCartApi(http: HttpClient): CartApi;
+//# sourceMappingURL=api.d.ts.map

package/dist/cart/api.js

@@ -0,0 +1,16 @@
+// The calls of commerce-core that are about the cart (`/cart`), each asking one thing and giving back what the store answers, unchanged. No state here (where a guest keeps their lines, which cart is shown,
+// when to merge): that is the layer above. Whose cart it is comes from the JWT the client carries (`getHeaders`, or `accessToken` for one call): `total` and `verifyPromotions` work with or without one.
+const bearer = (options) => (options?.accessToken ? { Authorization: `Bearer ${options.accessToken}` } : {});
+const part = (id) => encodeURIComponent(id);
+export function createCartApi(http) {
+    return {
+        get: (input, options) => http.request({ path: '/cart', query: { langCode: input?.langCode, cartTrackingId: input?.cartTrackingId }, headers: bearer(options), signal: options?.signal }),
+        addItem: (input, options) => http.request({ method: 'POST', path: '/cart', body: input, headers: bearer(options), signal: options?.signal }),
+        updateItem: (id, input, options) => http.request({ method: 'PATCH', path: `/cart/${part(id)}`, body: input, headers: bearer(options), signal: options?.signal }),
+        removeItem: (id, options) => http.request({ method: 'DELETE', path: `/cart/${part(id)}`, headers: bearer(options), signal: options?.signal }),
+        merge: (input, options) => http.request({ method: 'POST', path: '/cart/merge', body: input, headers: bearer(options), signal: options?.signal }),
+        total: (input, options) => http.request({ method: 'POST', path: '/cart/total', body: input, headers: bearer(options), signal: options?.signal }),
+        verifyPromotions: (input, options) => http.request({ method: 'POST', path: '/cart/promotion', body: input, headers: bearer(options), signal: options?.signal }),
+    };
+}
+//# sourceMappingURL=api.js.map

package/dist/cart/index.d.ts

@@ -0,0 +1,10 @@
+export { createCartApi } from './api.js';
+export type { CartApi } from './api.js';
+export { CART_ERROR_CODES } from './types.js';
+export type { Cart, CartItem, CartItemAction, CartItemOption, CartLineInput, CartMergeAnswer, CartShippingMethod, CartShippingZone, CartTaxZone, CartTotalInput, GetCartInput, MergeCartInput, Promotion, UpdateCartItemInput, VerifyPromotionsAnswer, VerifyPromotionsInput, } from './types.js';
+export { addLine, countOf, EMPTY_CART, linesOf, removeLine, setLineQuantity, unavailableItems } from './lines.js';
+export { browserKeyValuePort, createCartStorage, memoryKeyValuePort } from './storage.js';
+export type { CartStorage, CartStorageOptions, KeyValuePort } from './storage.js';
+export { createCartStore } from './store.js';
+export type { CartOwner, CartState, CartStore, CartStoreOptions } from './store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cart/index.js

@@ -0,0 +1,6 @@
+export { createCartApi } from './api.js';
+export { CART_ERROR_CODES } from './types.js';
+export { addLine, countOf, EMPTY_CART, linesOf, removeLine, setLineQuantity, unavailableItems } from './lines.js';
+export { browserKeyValuePort, createCartStorage, memoryKeyValuePort } from './storage.js';
+export { createCartStore } from './store.js';
+//# sourceMappingURL=index.js.map

package/dist/cart/lines.d.ts

@@ -0,0 +1,15 @@
+import type { Cart, CartLineInput } from './types.js';
+/** The empty cart, priced: what there is when there are no lines (nothing is asked of the store for it). */
+export declare const EMPTY_CART: Cart;
+/** The lines with this one added: a variant already there is ADDED TO (the way the store keeps a cart: one line for each variant) and keeps its price; a new one goes last. */
+export declare function addLine(lines: readonly CartLineInput[], line: CartLineInput): CartLineInput[];
+/** The lines with a variant's quantity replaced. A variant that is not there changes nothing. */
+export declare function setLineQuantity(lines: readonly CartLineInput[], variantId: string, quantity: number): CartLineInput[];
+export declare const removeLine: (lines: readonly CartLineInput[], variantId: string) => CartLineInput[];
+/** How many items: the sum of the quantities. */
+export declare const countOf: (lines: readonly CartLineInput[]) => number;
+/** A priced cart read as lines (what a customer's cart is). */
+export declare const linesOf: (cart: Cart) => CartLineInput[];
+/** What a priced cart cannot sell now: its lines that are not available (they are left out of its totals). */
+export declare const unavailableItems: (cart: Cart) => Cart["items"];
+//# sourceMappingURL=lines.d.ts.map

package/dist/cart/lines.js

@@ -0,0 +1,23 @@
+// What a cart IS, before what it costs: lines of (variant, price, how many). A guest's cart is made of these and a customer's is read into them. What a quantity or a cart may be (how many of a variant, how many
+// variants) is the STORE's to say: nothing here limits it, and the store's 400 is what a request that goes over gets.
+/** The empty cart, priced: what there is when there are no lines (nothing is asked of the store for it). */
+export const EMPTY_CART = { items: [], totalAmount: 0, totalGrossAmount: 0 };
+/** The lines with this one added: a variant already there is ADDED TO (the way the store keeps a cart: one line for each variant) and keeps its price; a new one goes last. */
+export function addLine(lines, line) {
+    const at = lines.findIndex((l) => l.variantId === line.variantId);
+    if (at >= 0)
+        return lines.map((l, i) => (i === at ? { ...l, quantity: l.quantity + line.quantity } : l));
+    return [...lines, { variantId: line.variantId, priceId: line.priceId, quantity: line.quantity }];
+}
+/** The lines with a variant's quantity replaced. A variant that is not there changes nothing. */
+export function setLineQuantity(lines, variantId, quantity) {
+    return lines.map((l) => (l.variantId === variantId ? { ...l, quantity } : l));
+}
+export const removeLine = (lines, variantId) => lines.filter((l) => l.variantId !== variantId);
+/** How many items: the sum of the quantities. */
+export const countOf = (lines) => lines.reduce((sum, l) => sum + l.quantity, 0);
+/** A priced cart read as lines (what a customer's cart is). */
+export const linesOf = (cart) => cart.items.map((i) => ({ variantId: i.variantId, priceId: i.priceId, quantity: i.quantity }));
+/** What a priced cart cannot sell now: its lines that are not available (they are left out of its totals). */
+export const unavailableItems = (cart) => cart.items.filter((i) => !i.isAvailable);
+//# sourceMappingURL=lines.js.map

package/dist/cart/storage.d.ts

@@ -0,0 +1,30 @@
+import type { CartLineInput } from './types.js';
+export interface KeyValuePort {
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+}
+/** What the cart keeps. */
+export interface CartStorage {
+    /** The guest's lines (what is kept that is not a line a store would take is left out). */
+    lines(): CartLineInput[];
+    saveLines(lines: readonly CartLineInput[]): void;
+    clearLines(): void;
+    /**
+     * The id the store knows this cart by, for its analytics (a cart that was left): made the first time it is asked for and kept, so it is the SAME from a guest's cart to the customer's after logging in.
+     * It is sent with every call that reads the cart. It goes (`forgetTrackingId`) when the cart is empty: the next one is another cart.
+     */
+    trackingId(): string;
+    forgetTrackingId(): void;
+}
+export interface CartStorageOptions {
+    /** Makes a tracking id; by default a random UUID. */
+    makeTrackingId?: () => string;
+}
+/** What the browser's `localStorage` says, and no more: where it is not there, or refuses (a private window, a full disk), what is kept is kept in memory for as long as the page lives. */
+export declare function browserKeyValuePort(): KeyValuePort;
+export declare function memoryKeyValuePort(initial?: Record<string, string>): KeyValuePort & {
+    all(): Record<string, string>;
+};
+export declare function createCartStorage(port: KeyValuePort, storeId: string, options?: CartStorageOptions): CartStorage;
+//# sourceMappingURL=storage.d.ts.map

package/dist/cart/storage.js

@@ -0,0 +1,82 @@
+/** What the browser's `localStorage` says, and no more: where it is not there, or refuses (a private window, a full disk), what is kept is kept in memory for as long as the page lives. */
+export function browserKeyValuePort() {
+    const fallback = memoryKeyValuePort();
+    const local = () => {
+        try {
+            return globalThis.localStorage ?? null;
+        }
+        catch {
+            return null;
+        }
+    };
+    return {
+        get(key) { try {
+            return local()?.getItem(key) ?? fallback.get(key);
+        }
+        catch {
+            return fallback.get(key);
+        } },
+        set(key, value) { try {
+            const s = local();
+            if (s) {
+                s.setItem(key, value);
+                fallback.remove(key);
+                return;
+            }
+        }
+        catch { /* falls to memory */ } fallback.set(key, value); },
+        remove(key) { try {
+            local()?.removeItem(key);
+        }
+        catch { /* nothing to do */ } fallback.remove(key); },
+    };
+}
+export function memoryKeyValuePort(initial = {}) {
+    const map = new Map(Object.entries(initial));
+    return { get: (key) => map.get(key) ?? null, set: (key, value) => { map.set(key, value); }, remove: (key) => { map.delete(key); }, all: () => Object.fromEntries(map) };
+}
+/** A line as it may have been kept: only what is a line (variant, price, a whole quantity of 1 or more), once for each variant. What the store accepts of it is the store's to say. */
+function clean(value) {
+    if (!Array.isArray(value))
+        return [];
+    const seen = new Set();
+    const lines = [];
+    for (const raw of value) {
+        const l = raw;
+        if (!l || typeof l.variantId !== 'string' || typeof l.priceId !== 'string' || !Number.isInteger(l.quantity) || l.quantity < 1 || seen.has(l.variantId))
+            continue;
+        seen.add(l.variantId);
+        lines.push({ variantId: l.variantId, priceId: l.priceId, quantity: l.quantity });
+    }
+    return lines;
+}
+export function createCartStorage(port, storeId, options = {}) {
+    const linesKey = `wrCart_${storeId}`;
+    const idKey = `wrCartTrackingId_${storeId}`;
+    const makeId = options.makeTrackingId ?? (() => globalThis.crypto.randomUUID());
+    return {
+        lines() {
+            const text = port.get(linesKey);
+            if (text === null)
+                return [];
+            try {
+                return clean(JSON.parse(text));
+            }
+            catch {
+                return [];
+            }
+        },
+        saveLines: (lines) => port.set(linesKey, JSON.stringify(lines)),
+        clearLines: () => port.remove(linesKey),
+        trackingId() {
+            const known = port.get(idKey);
+            if (known)
+                return known;
+            const made = makeId();
+            port.set(idKey, made);
+            return made;
+        },
+        forgetTrackingId: () => port.remove(idKey),
+    };
+}
+//# sourceMappingURL=storage.js.map

package/dist/cart/store.d.ts

@@ -0,0 +1,58 @@
+import { CommerceError } from '../errors.js';
+import type { AuthStore } from '../auth/store.js';
+import type { CartApi } from './api.js';
+import type { CartStorage } from './storage.js';
+import type { Cart, CartLineInput, CartMergeAnswer } from './types.js';
+export type CartOwner = 'unknown' | 'guest' | 'customer';
+export interface CartState {
+    /** Whose cart this is. `unknown` until it is known whether a customer is logged in. */
+    owner: CartOwner;
+    /** What is in the cart: which variants, at which price, how many. */
+    lines: CartLineInput[];
+    /** How many items: the sum of the quantities (what a badge says; known before the store has priced anything). */
+    count: number;
+    /** What the store says the cart costs, or null until it said. While `isStale`, it is the answer to the lines before the last change. */
+    priced: Cart | null;
+    isStale: boolean;
+    /** An action or a call is under way. */
+    busy: boolean;
+    /** What stopped the cart from being priced, read or merged without being an action's own failure (those throw): it goes when it works again. */
+    error: CommerceError | null;
+    /** What the store said of the last merge of a guest's lines (`fallbackApplied`: it had to leave some out). */
+    lastMerge: CartMergeAnswer | null;
+}
+export interface CartStore {
+    getState(): CartState;
+    subscribe(listener: () => void): () => void;
+    /** Starts following whether a customer is logged in (asks the auth store to find out) and reads the cart. Once. */
+    start(): Promise<void>;
+    /** Adds to the cart (a variant that is already there is added to). Throws what the store refuses: `CART_LIMIT_REACHED`, `CART_CURRENCY_MISMATCH`, a quantity out of 1 to 10000. */
+    add(line: CartLineInput): Promise<void>;
+    /** Replaces the quantity of a variant that is in the cart (1 to 10000). */
+    setQuantity(variantId: string, quantity: number): Promise<void>;
+    remove(variantId: string): Promise<void>;
+    /** Asks the store again: what it costs now (the guest's), or what the cart is (the customer's). */
+    refresh(): Promise<void>;
+    /**
+     * After an order was paid (the success page): a guest's cart is emptied here (the lines and the tracking id kept in the browser), and a customer's, which the store emptied by itself, is read again.
+     * Nothing is asked of the store for a guest's.
+     */
+    clear(): Promise<void>;
+    /** Stops following the auth store. */
+    dispose(): void;
+}
+export interface CartStoreOptions {
+    api: CartApi;
+    /** Whose cart: only what is needed to follow it. */
+    auth: Pick<AuthStore, 'getState' | 'subscribe' | 'restore'>;
+    storage: CartStorage;
+    /** The language the store answers in (names, options): read at each call, so a site that changes language gets the new one at the next. */
+    langCode?: () => string | undefined;
+    /**
+     * Whether a guest's cart is priced with `/cart/total` after every change (default: yes). A site that prices and describes its cart with the checkout's preview (`commerce.checkout`: its lines carry the names, the
+     * pictures, the stock and the totals) says no: the guest's lines are kept and counted, `priced` stays null and `/cart/total` is never called. A customer's cart is still read with `/cart/get`: it is where its lines are.
+     */
+    pricing?: boolean;
+}
+export declare function createCartStore(options: CartStoreOptions): CartStore;
+//# sourceMappingURL=store.d.ts.map

package/dist/cart/store.js

@@ -0,0 +1,218 @@
+import { toCommerceError } from '../errors.js';
+import { createStateHolder, createSerialQueue, followAuth } from '../store-kit.js';
+import { addLine, countOf, EMPTY_CART, linesOf, removeLine, setLineQuantity } from './lines.js';
+/**
+ * A refusal that asking again will not change: the lines are wrong for the store (400, a variant that is gone 404, 409, 422), not the store away. A 401 is the session's (renewed elsewhere), a 429 passes, and a
+ * 403 is asked again: the store answers "Customer not found" to a call made at once after a signup (it answers before it has saved), and that is over in a moment.
+ */
+const isDefinite = (error) => error.kind === 'http' && (error.status === 400 || error.status === 404 || error.status === 409 || error.status === 422);
+export function createCartStore(options) {
+    const { api, auth, storage } = options;
+    const lang = () => options.langCode?.();
+    const holder = createStateHolder({ owner: 'unknown', lines: [], count: 0, priced: null, isStale: false, busy: false, error: null, lastMerge: null });
+    const set = holder.set;
+    // Counts the times the cart changed hands: an answer that comes after that is about a cart that is not this one any more
+    let epoch = 0;
+    const queue = createSerialQueue((busy) => set({ busy }));
+    // A pricing already waiting its turn is enough for any number of changes made before it starts
+    let pricing = null;
+    // A merge the store refused for the lines (not for being away) is not asked again until the customer logs in again
+    let mergeRefused = false;
+    // Why the last merge did not happen (the lines are still in the browser): it stays in `error` until a merge works
+    let mergeError = null;
+    const withLines = (lines, extra = {}) => ({ lines, count: countOf(lines), ...extra });
+    // ── the guest's cart ─────────────────────────────────────────
+    async function priceGuest() {
+        const mine = epoch;
+        const lines = holder.get().lines;
+        if (lines.length === 0) {
+            storage.forgetTrackingId();
+            set({ priced: EMPTY_CART, isStale: false, error: null });
+            return;
+        }
+        // A site that prices with the checkout's preview does not ask `/cart/total`: the lines are all the guest's cart is
+        if (options.pricing === false) {
+            set({ isStale: false, error: null });
+            return;
+        }
+        try {
+            const priced = await api.total({ langCode: lang(), items: lines, cartTrackingId: storage.trackingId() });
+            if (epoch !== mine)
+                return;
+            // Lines that changed meanwhile have a pricing of their own coming: this answer is one change behind
+            set({ priced, isStale: holder.get().lines !== lines, error: null });
+        }
+        catch (error) {
+            if (epoch === mine)
+                set({ error: toCommerceError(error), isStale: true });
+        }
+    }
+    function schedulePricing() {
+        if (pricing)
+            return pricing;
+        const mine = epoch;
+        const task = queue.run(async () => {
+            pricing = null;
+            if (epoch === mine && holder.get().owner === 'guest')
+                await priceGuest();
+        });
+        pricing = task;
+        return task;
+    }
+    // ── the customer's cart ──────────────────────────────────────
+    /** The lines the customer logged in with go into their cart; the browser forgets them only when the store has them. */
+    async function mergeLocal() {
+        const local = storage.lines();
+        if (local.length === 0 || mergeRefused)
+            return;
+        try {
+            const answer = await api.merge({ langCode: lang(), items: local });
+            // The store has them: they go, whoever the cart belongs to by now
+            storage.clearLines();
+            mergeError = null;
+            set({ lastMerge: answer, error: null });
+            // A customer who logged out meanwhile has the browser's cart again, and what it had is the customer's now
+            if (holder.get().owner === 'guest') {
+                set(withLines(storage.lines(), { isStale: storage.lines().length > 0 }));
+                void schedulePricing();
+            }
+        }
+        catch (error) {
+            mergeError = toCommerceError(error);
+            if (isDefinite(mergeError))
+                mergeRefused = true;
+            set({ error: mergeError });
+        }
+    }
+    async function loadCustomer() {
+        const mine = epoch;
+        await mergeLocal();
+        if (epoch !== mine)
+            return;
+        try {
+            const priced = await api.get({ langCode: lang(), cartTrackingId: storage.trackingId() });
+            if (epoch !== mine)
+                return;
+            if (priced.items.length === 0)
+                storage.forgetTrackingId();
+            const lines = linesOf(priced);
+            set(withLines(lines, { priced, isStale: false, error: mergeError }));
+        }
+        catch (error) {
+            if (epoch === mine)
+                set({ error: toCommerceError(error), isStale: true });
+        }
+    }
+    /** What the store holds of a variant in the customer's cart: the line's own id, asking again for the cart first when it is not known (a line just added). */
+    async function lineIdOf(variantId) {
+        const find = () => holder.get().priced?.items.find((i) => i.variantId === variantId)?.id;
+        return find() ?? (await loadCustomer(), find());
+    }
+    /** A customer's action: what the customer sees changes at once; the call goes in its turn; when the last one is done the cart is read again, so what is shown is what the store holds, a refusal included. */
+    function customerAction(lines, call) {
+        const mine = epoch;
+        set(withLines(lines, { isStale: true }));
+        return queue.run(async () => {
+            try {
+                if (epoch === mine)
+                    await call();
+            }
+            finally {
+                if (queue.pending() === 1 && epoch === mine)
+                    await loadCustomer();
+            }
+        });
+    }
+    // ── following who is logged in ───────────────────────────────
+    function toGuest() {
+        epoch++;
+        pricing = null;
+        const lines = storage.lines();
+        set(withLines(lines, { owner: 'guest', priced: null, isStale: lines.length > 0, error: null, lastMerge: null }));
+        void schedulePricing();
+    }
+    function toCustomer() {
+        epoch++;
+        pricing = null;
+        mergeRefused = false;
+        mergeError = null;
+        // The guest's lines stay in sight until the merge is done: the badge does not blink to 0
+        set({ owner: 'customer', priced: null, isStale: true, error: null });
+        void queue.run(loadCustomer);
+    }
+    const following = followAuth(auth, { current: () => holder.get().owner, toGuest, toCustomer });
+    function start() {
+        // What the browser kept is known before anything is asked: a badge can say it at once
+        const kept = storage.lines();
+        if (kept.length > 0 && holder.get().owner === 'unknown')
+            set(withLines(kept));
+        return following.start();
+    }
+    return {
+        getState: holder.get,
+        subscribe: holder.subscribe,
+        start,
+        async add(line) {
+            if (holder.get().owner === 'unknown')
+                await start();
+            if (holder.get().owner === 'customer')
+                return customerAction(addLine(holder.get().lines, line), async () => { await api.addItem(line); });
+            const lines = addLine(holder.get().lines, line);
+            storage.saveLines(lines);
+            set(withLines(lines, { isStale: true }));
+            return schedulePricing();
+        },
+        async setQuantity(variantId, quantity) {
+            if (holder.get().owner === 'unknown')
+                await start();
+            const lines = setLineQuantity(holder.get().lines, variantId, quantity);
+            if (holder.get().owner === 'customer') {
+                return customerAction(lines, async () => {
+                    const id = await lineIdOf(variantId);
+                    if (id !== undefined)
+                        await api.updateItem(id, { quantity });
+                });
+            }
+            storage.saveLines(lines);
+            set(withLines(lines, { isStale: true }));
+            return schedulePricing();
+        },
+        async remove(variantId) {
+            if (holder.get().owner === 'unknown')
+                await start();
+            const lines = removeLine(holder.get().lines, variantId);
+            if (holder.get().owner === 'customer') {
+                return customerAction(lines, async () => {
+                    const id = await lineIdOf(variantId);
+                    if (id !== undefined)
+                        await api.removeItem(id);
+                });
+            }
+            storage.saveLines(lines);
+            set(withLines(lines, { isStale: true }));
+            return schedulePricing();
+        },
+        async refresh() {
+            if (holder.get().owner === 'unknown')
+                await start();
+            if (holder.get().owner === 'customer')
+                return queue.run(loadCustomer);
+            if (holder.get().owner === 'guest')
+                return schedulePricing();
+        },
+        async clear() {
+            if (holder.get().owner === 'unknown')
+                await start();
+            if (holder.get().owner === 'customer')
+                return queue.run(loadCustomer);
+            // An answer that is on its way is about lines that are not there any more
+            epoch++;
+            pricing = null;
+            storage.clearLines();
+            storage.forgetTrackingId();
+            set(withLines([], { priced: EMPTY_CART, isStale: false, error: null }));
+        },
+        dispose: following.stop,
+    };
+}
+//# sourceMappingURL=store.js.map