@occluze/tether 0.6.7 → 0.7.0

package/dist/types/src/astro.d.ts

@@ -0,0 +1,42 @@
+import type { TetherOptions } from './config.js';
+import type { StorefrontOptions } from './server.js';
+interface AstroLogger {
+    warn: (message: string) => void;
+}
+/** The argument of Astro's `astro:config:setup` hook. */
+interface AstroConfigSetup {
+    injectScript: (stage: 'head-inline' | 'page', content: string) => void;
+    /** `dev`, `build`, `preview` or `sync`. */
+    command: string;
+    config: {
+        root?: URL;
+    };
+    logger: AstroLogger;
+    addWatchFile?: (path: string) => void;
+    /** Takes a partial Astro config. A method, so that Astro's own `DeepPartial<AstroConfig>` parameter fits. */
+    updateConfig?(config: {
+        env?: {
+            schema?: Record<string, unknown>;
+        };
+    }): unknown;
+}
+/** The config options a page can be handed as JSON: all but the functions. */
+type SerializableOptions = {
+    [Key in keyof TetherOptions as Exclude<TetherOptions[Key], null | undefined> extends (...args: never[]) => unknown ? never : Key]?: TetherOptions[Key];
+};
+/** `createStorefront()`'s own options that a config shared with it may hold, which the page leaves out. */
+type ServerOnlyOptions = Pick<StorefrontOptions, 'siteUrl' | 'pageSize'>;
+/** Tether's serializable config and the storefront's own options, plus the integration's own options. */
+interface TetherAstroOptions extends SerializableOptions, ServerOnlyOptions {
+    /** Add the Tether script to every page (default true). */
+    inject?: boolean;
+    /** Files that restart the dev server when they change. */
+    watch?: string[] | null;
+}
+export type { TetherAstroOptions, AstroConfigSetup };
+export default function tether(options?: TetherAstroOptions): {
+    name: string;
+    hooks: {
+        'astro:config:setup': (setup: AstroConfigSetup) => Promise<void>;
+    };
+};

package/dist/types/src/cart/cart-shape.d.ts

@@ -0,0 +1,43 @@
+export declare const CART: {
+    readonly id: "string";
+    readonly checkoutUrl: "string";
+    readonly totalQuantity: "number";
+    readonly attributes: readonly ["object"];
+    readonly discountCodes: readonly ["object"];
+    readonly cost: {
+        readonly totalAmount: {
+            readonly amount: "string";
+            readonly currencyCode: "string";
+        };
+        readonly subtotalAmount: {
+            readonly amount: "string";
+            readonly currencyCode: "string";
+        };
+    };
+    readonly lines: {
+        readonly nodes: readonly [{
+            readonly id: "string";
+            readonly quantity: "number";
+            readonly attributes: readonly ["object"];
+            readonly cost: {
+                readonly totalAmount: {
+                    readonly amount: "string";
+                    readonly currencyCode: "string";
+                };
+                readonly subtotalAmount: {
+                    readonly amount: "string";
+                    readonly currencyCode: "string";
+                };
+                readonly amountPerQuantity: {
+                    readonly amount: "string";
+                    readonly currencyCode: "string";
+                };
+            };
+            readonly merchandise: {
+                readonly id: "string";
+                readonly selectedOptions: readonly ["object"];
+                readonly product: "object";
+            };
+        }];
+    };
+};

package/dist/types/src/cart/checkout.d.ts

@@ -0,0 +1,16 @@
+import type { CheckoutTarget } from '../config.js';
+/**
+ * The logged-in customer's checkout URL for the cart; `null` when nobody is logged in, so the cart's own checkout URL
+ * is used.
+ */
+type CheckoutResolver = () => Promise<string | null>;
+/** Sets the account part's checkout URL, or clears it with `null`. A URL it answers opens checkout logged in. */
+export declare function setCheckoutResolver(resolver: CheckoutResolver | null): void;
+/**
+ * Goes to Shopify's checkout. With `_blank` the tab opens inside the click (Safari blocks `window.open` after an
+ * await) and gets its URL once there is one.
+ *
+ * @returns The checkout URL, `null` with nothing to check out or after a reported failure.
+ */
+export declare function checkout(target?: CheckoutTarget): Promise<string | null>;
+export {};

package/dist/types/src/cart/drawer.d.ts

@@ -0,0 +1,18 @@
+/** Every cart drawer on the page. */
+export declare const drawers: () => HTMLElement[];
+/** True while a drawer, or the drawer-less cart, is open. */
+export declare function isOpen(): boolean;
+/**
+ * `aria-expanded` on the open buttons, and dialog semantics on the drawers unless their markup has its own. A closed
+ * drawer is hidden from screen readers and, with `cartFocus`, out of the Tab order (inert), like a closed dialog.
+ */
+export declare function syncDrawerAria(open: boolean): void;
+/** Opens every drawer except `tether-cart-drawer="manual"` ones, which the site opens itself. */
+export declare function openCart(): void;
+export declare function closeCart(): void;
+export declare function toggleCart(): void;
+/**
+ * Keeps Tab inside the open drawer (`cartFocus`): from the last focusable element it wraps to the first, with Shift
+ * from the first to the last, and from outside the drawer it goes in. For a document `keydown` listener.
+ */
+export declare function trapFocus(event: KeyboardEvent): void;

package/dist/types/src/cart/mutations.d.ts

@@ -0,0 +1,79 @@
+import type { AttributeValue } from '../dom.js';
+import type { ShopifyCart, Attribute } from './store.js';
+export type Attributes = Record<string, AttributeValue> | {
+    key: string | number;
+    value?: AttributeValue;
+}[];
+/** A line to add, in any of the shapes `Cart.add` takes. */
+export interface LineSpec {
+    variantId?: string | number;
+    merchandiseId?: string | number;
+    id?: string | number;
+    quantity?: number | string;
+    sellingPlanId?: string | number | null;
+    sellingPlan?: string | number | null;
+    attributes?: Attributes | null;
+}
+/** Shopify's `CartLineInput`. */
+export interface CartLineInput {
+    merchandiseId: string;
+    quantity: number;
+    sellingPlanId?: string;
+    attributes?: Attribute[];
+}
+/**
+ * @returns True when `error` says Shopify doesn't have the cart, false for any other failure (the network, the token,
+ *   a line it refused), after which the saved cart is still good.
+ */
+export declare function isCartGone(error: unknown): boolean;
+/**
+ * @param input A variant id, or a line.
+ * @param quantity For a variant id.
+ * @param options For a variant id.
+ * @throws {TetherError} `ERROR` without a variant id.
+ */
+export declare function toLineInput(input: string | number | LineSpec | null | undefined, quantity?: number, options?: Omit<LineSpec, 'variantId' | 'quantity'>): CartLineInput;
+/** A mutation on the saved cart. */
+interface CartMutation {
+    /** The mutation, e.g. `cartLinesAdd`. */
+    name: string;
+    /** Its variable definitions besides `$cartId`. */
+    args: string;
+    /** Its arguments besides `cartId`. */
+    inner: string;
+    variables: Record<string, unknown>;
+    /**
+     * The `CartInput` of a new cart that does what the mutation asks, when there is no cart (or Shopify no longer has
+     * it); `null` leaves the visitor without a cart instead.
+     */
+    createInput: Record<string, unknown> | null;
+}
+/**
+ * Runs a mutation on the saved cart, or creates a cart from `createInput` when there is none to change.
+ *
+ * @returns The changed cart; `null` without a cart and without a `createInput`.
+ * @throws {TetherError} For a failed request or Shopify's user errors; also when the cart is gone and there is no
+ *   `createInput` (the saved cart is forgotten first).
+ */
+export declare function mutateCart({ name, args, inner, variables, createInput, }: CartMutation): Promise<ShopifyCart | null>;
+/** @returns The cart, `null` when Shopify doesn't have it (expired or checked out). */
+export declare function fetchCart(id: string): Promise<ShopifyCart | null>;
+/** @returns The cart's current checkout URL, `null` when Shopify doesn't have the cart. */
+export declare function fetchCheckoutUrl(id: string): Promise<string | null>;
+/** A change to one line, for `updateLine`. */
+export interface LinePatch {
+    /** 0 or less removes the line. */
+    quantity?: number;
+    /** `null` switches the line back to one-time purchase. */
+    sellingPlanId?: string | number | null;
+    attributes?: Attributes;
+    merchandiseId?: string | number;
+    variantId?: string | number;
+}
+/** @returns Shopify's `CartLineUpdateInput`. */
+export declare function toLineUpdate(lineId: string, patch: number | LinePatch): Record<string, unknown>;
+export declare const updateLines: (lines: Record<string, unknown>[]) => Promise<ShopifyCart | null>;
+export declare const removeLines: (lineIds: string[]) => Promise<ShopifyCart | null>;
+/** @returns The cart once `lineId` has `target` (0 removes it). */
+export declare const setLineQuantity: (lineId: string, target: number) => Promise<ShopifyCart | null>;
+export {};

package/dist/types/src/cart/render.d.ts

@@ -0,0 +1,17 @@
+import type { CartWarning } from '../config.js';
+import type { ShopifyCart, ShopifyCartLine, PendingQuantity } from './store.js';
+/** What a render shows. */
+interface CartView {
+    cart: ShopifyCart | null;
+    warnings: readonly CartWarning[];
+    /** Line id → the quantity quick clicks asked for. */
+    pending: ReadonlyMap<string, PendingQuantity>;
+    /** The last load or change failed (`tether-show="cart-error"`). */
+    failed: boolean;
+}
+/** @returns The quantity to show: the one asked for while an update is on its way. */
+export declare const quantityOf: (line: ShopifyCartLine, pending: ReadonlyMap<string, PendingQuantity>) => number;
+export declare function renderCart(view: CartView): void;
+/** Shows the count a saved cart had on the last page in the cart counts the page left at 0, until it has loaded. */
+export declare function showSavedCount(count: number): void;
+export {};

package/dist/types/src/cart/store.d.ts

@@ -0,0 +1,182 @@
+import type { CartWarning } from '../config.js';
+import type { Image } from '../fragments.js';
+import type { Money } from '../shopify-values.js';
+export interface Attribute {
+    key: string;
+    value: string;
+}
+/** A line's `merchandise`: Shopify's `Merchandise` union has only `ProductVariant`. */
+export interface CartVariant {
+    id: string;
+    title: string;
+    sku: string | null;
+    availableForSale: boolean;
+    requiresShipping: boolean;
+    /** Absent when the store's token can't read inventory. */
+    quantityAvailable?: number | null;
+    image: Image | null;
+    price: Money;
+    compareAtPrice: Money | null;
+    selectedOptions: {
+        name: string;
+        value: string;
+    }[];
+    product: {
+        id: string;
+        title: string;
+        handle: string;
+        vendor: string;
+        featuredImage: Image | null;
+    };
+}
+interface LinePlanAllocation {
+    sellingPlan: {
+        id: string;
+        name: string;
+        description: string | null;
+        recurringDeliveries: boolean;
+        options: {
+            name: string;
+            value: string;
+        }[];
+    };
+    checkoutChargeAmount: Money;
+    priceAdjustments: {
+        price: Money;
+        compareAtPrice: Money;
+        perDeliveryPrice: Money;
+    }[];
+}
+export interface ShopifyCartLine {
+    id: string;
+    quantity: number;
+    attributes: Attribute[];
+    cost: {
+        totalAmount: Money;
+        subtotalAmount: Money;
+        amountPerQuantity: Money;
+        compareAtAmountPerQuantity: Money | null;
+    };
+    discountAllocations: {
+        discountedAmount: Money;
+    }[];
+    sellingPlanAllocation: LinePlanAllocation | null;
+    merchandise: CartVariant;
+    /** Only on a bundle (`ComponentizableCartLine`). */
+    lineComponents?: {
+        id: string;
+        quantity: number;
+        merchandise: {
+            id: string;
+            title: string;
+            product: {
+                title: string;
+                handle: string;
+            };
+        };
+    }[];
+}
+/** The fields of `fragment TetherCart`. */
+export interface ShopifyCart {
+    id: string;
+    checkoutUrl: string;
+    totalQuantity: number;
+    note: string | null;
+    createdAt: string;
+    updatedAt: string;
+    attributes: Attribute[];
+    buyerIdentity: {
+        countryCode: string | null;
+        email: string | null;
+    };
+    discountCodes: {
+        code: string;
+        applicable: boolean;
+    }[];
+    cost: {
+        subtotalAmount: Money;
+        totalAmount: Money;
+        checkoutChargeAmount: Money;
+    };
+    lines: {
+        nodes: ShopifyCartLine[];
+    };
+}
+/**
+ * `unknown` until the saved cart has loaded (the page's own markup shows); `empty` without a cart (none saved, or
+ * Shopify no longer has it); `error` after a failed load or change, with the cart as Shopify last sent it.
+ */
+export type CartStatus = {
+    kind: 'unknown';
+} | {
+    kind: 'empty';
+} | {
+    kind: 'ready';
+    cart: ShopifyCart;
+} | {
+    kind: 'error';
+    error: unknown;
+    cart: ShopifyCart | null;
+};
+/** What one quick +/- click asked for; a newer click replaces it. */
+export interface PendingQuantity {
+    quantity: number;
+}
+/** The second argument of a `subscribe` listener. */
+interface CartMeta {
+    open: boolean;
+    count: number;
+    loaded: boolean;
+    /** A copy of Shopify's notes on the last change. */
+    warnings: CartWarning[];
+}
+/** Line id → what quick +/- clicks asked for, until Shopify has answered. */
+export declare const pendingQuantities: Map<string, PendingQuantity>;
+export declare const cartStatus: () => CartStatus;
+/** The cart as Shopify last sent it. */
+export declare function currentCart(): ShopifyCart | null;
+export declare const currentWarnings: () => readonly CartWarning[];
+/** The id of the visitor's cart, kept across pages. */
+export declare const savedCartId: () => string | null;
+/** Forgets the saved cart, which Shopify no longer has. */
+export declare function forgetSavedCart(): void;
+/** Keeps a cart Shopify sent without showing it, for an answer a newer change will replace. */
+export declare function keepQuietly(cart: ShopifyCart | null): void;
+/** Renders the document with the store's cart. */
+export declare function render(): void;
+/** @param reason The `reason` of `tether:cart-updated`. */
+export declare function announce(reason: string): void;
+/**
+ * Keeps a cart Shopify sent after a change, shows it, and tells this page and the visitor's other tabs.
+ *
+ * @returns `cart`.
+ */
+export declare function commit(cart: ShopifyCart | null, reason: string): ShopifyCart | null;
+/** The outcome of loading the saved cart: the cart, `null` when there is none, or the failure. */
+export declare function settleLoad(outcome: {
+    kind: 'loaded';
+    cart: ShopifyCart | null;
+} | {
+    kind: 'failed';
+    error: unknown;
+}): void;
+/** Until the saved cart has loaded, the counts show the count it had on the last page instead of the page's 0. */
+export declare function showLastKnownCount(): void;
+/** Sets Shopify's notes on the last change: each message once, in the site's words (`warningText`). */
+export declare function setWarnings(notes: readonly CartWarning[]): void;
+/** @returns A runner that starts each task once the one before has settled, whether it succeeded or failed. */
+export declare function serial(): <T>(task: () => Promise<T>) => Promise<T>;
+/**
+ * Runs a cart change after the ones before it, so quick clicks never race. A failure sets the `error` status (shown by
+ * `tether-show="cart-error"` until the next change succeeds), emits `tether:cart-error` and rejects.
+ */
+export declare function enqueue<T>(task: () => Promise<T>): Promise<T>;
+/** @returns The quantity to show for `line`. */
+export declare const pendingQuantityOf: (line: ShopifyCartLine) => number;
+/**
+ * Calls `listener` now and after every change of the cart or the drawer.
+ *
+ * @returns Stops listening.
+ */
+export declare function subscribe(listener: (cart: ShopifyCart | null, meta: CartMeta) => void): () => void;
+export {};

package/dist/types/src/cart.d.ts

@@ -0,0 +1,106 @@
+import { checkout, setCheckoutResolver } from './cart/checkout.js';
+import { isOpen, openCart, closeCart, toggleCart, trapFocus } from './cart/drawer.js';
+import { render, subscribe } from './cart/store.js';
+import type { CartWarning } from './config.js';
+import type { Attributes, LineSpec, LinePatch } from './cart/mutations.js';
+import type { ShopifyCart, ShopifyCartLine, CartStatus } from './cart/store.js';
+export { trapFocus };
+type DiscountCodes = string[] | string | ((current: string[]) => string[]);
+/**
+ * +1 / -1 for a line. Quick clicks add up: each builds on the quantity the click before asked for, which shows at once
+ * (`tether-line="quantity"`, `quantityOf`) until Shopify has answered. Only the latest target is sent; the ones it
+ * replaced are skipped.
+ */
+declare function changeQuantity(lineId: string, delta: number): Promise<ShopifyCart | null>;
+/**
+ * Loads the saved cart. A cart Shopify no longer has is forgotten; one it can't be asked about (the network, the
+ * token) is kept, because it is probably fine.
+ */
+declare function init(): Promise<ShopifyCart | null>;
+export declare const Cart: {
+    init: typeof init;
+    /** The saved cart's id. */
+    id: () => string | null;
+    readonly status: CartStatus;
+    readonly state: ShopifyCart | null;
+    /** The cart's lines, a copy: changing it changes nothing in the cart. */
+    readonly lines: ShopifyCartLine[];
+    readonly count: number;
+    /** True once the saved cart, or that there is none, is known. */
+    readonly loaded: boolean;
+    /**
+     * The failure of the last load or change, until a change succeeds. Requests fail with an `Error`; anything else
+     * thrown is wrapped, so the public type holds.
+     */
+    readonly lastError: Error | null;
+    /** Shopify's notes on the last change, a copy. */
+    readonly warnings: CartWarning[];
+    /** Line id → the quantity quick clicks asked for. */
+    readonly pendingQty: ReadonlyMap<string, {
+        quantity: number;
+    }>;
+    /**
+     * Sets where a logged-in customer checks out, or clears it with `null`: the account part's resolver answers the
+     * customer's checkout URL for the cart (`null` uses the cart's own).
+     */
+    setCheckoutResolver: typeof setCheckoutResolver;
+    /**
+     * Forgets the saved cart on this device, as if there were none: the page shows an empty cart and
+     * `tether:cart-updated` fires with reason `load`. The next add starts a new cart.
+     */
+    forgetSaved(): void;
+    render: typeof render;
+    subscribe: typeof subscribe;
+    /**
+     * `add(variantId, 2)`, `add({ variantId, quantity, sellingPlanId, attributes })`, or `add([line, line])` for
+     * bundles in one request. Creates the cart when there is none.
+     *
+     * @throws {TetherError} (rejected) When the add fails, or Shopify answers it without a cart.
+     */
+    add(input: string | number | LineSpec | (string | number | LineSpec)[], quantity?: number, options?: Omit<LineSpec, "variantId" | "quantity">): Promise<ShopifyCart>;
+    /**
+     * `updateLine(lineId, 3)` or `updateLine(lineId, { quantity, sellingPlanId, attributes })`.
+     *
+     * @param patch A quantity of 0 or less removes the line.
+     */
+    updateLine(lineId: string, patch: number | LinePatch): Promise<ShopifyCart | null>;
+    changeQuantity: typeof changeQuantity;
+    /** The quantity to show: the one asked for while an update is on its way. */
+    quantityOf: (line: ShopifyCartLine) => number;
+    removeLine(lineIds: string | string[]): Promise<ShopifyCart | null>;
+    clear(): Promise<ShopifyCart | null>;
+    setNote(note: string | null | undefined): Promise<ShopifyCart | null>;
+    /**
+     * Cart attributes, merged with the cart's (as it is when the change runs, so quick calls don't drop each other).
+     *
+     * @param attributes The value `''` removes a key.
+     */
+    setAttributes(attributes: Attributes): Promise<ShopifyCart | null>;
+    /** Replaces the discount codes; `[]` removes them all. */
+    setDiscountCodes(codes: DiscountCodes): Promise<ShopifyCart | null>;
+    /**
+     * Adds a code. A code Shopify doesn't accept is removed again, so it doesn't warn on every later change.
+     *
+     * @throws {TetherError} `INVALID_DISCOUNT` (rejected) when Shopify doesn't accept the code.
+     */
+    applyDiscount(code: string): Promise<ShopifyCart | null>;
+    removeDiscount(code: string): Promise<ShopifyCart | null>;
+    /**
+     * Sets who is buying; a country changes the cart's currency and prices to that market's.
+     *
+     * @param options `create: false` forgets an expired cart instead of creating an empty one.
+     */
+    setBuyerIdentity(buyerIdentity: {
+        countryCode?: string;
+        email?: string;
+        phone?: string;
+    }, { create }?: {
+        create?: boolean;
+    }): Promise<ShopifyCart | null>;
+    checkout: typeof checkout;
+    drawers: () => HTMLElement[];
+    isOpen: typeof isOpen;
+    open: typeof openCart;
+    close: typeof closeCart;
+    toggle: typeof toggleCart;
+};

package/dist/types/src/client.d.ts

@@ -0,0 +1,100 @@
+import type { TetherConfig } from './config.js';
+export type TetherErrorCode = 'NOT_FOUND' | 'NETWORK' | 'NOT_CONFIGURED' | 'NOT_LOGGED_IN' | 'INVALID' | 'INVALID_COUNTRY' | 'INVALID_DISCOUNT' | 'ERROR' | `HTTP_${number}`;
+export interface GraphQLError {
+    message: string;
+    extensions?: {
+        code?: string;
+    };
+}
+export interface UserError {
+    message: string;
+    field?: string[] | null;
+    code?: string | null;
+}
+interface TetherErrorDetails {
+    /** Default `HTTP_<status>` with a status, else `ERROR`. */
+    code?: TetherErrorCode;
+    /** The HTTP status of the response that failed. */
+    status?: number;
+    /** The GraphQL errors of that response. */
+    errors?: GraphQLError[];
+    /** A mutation's user errors. */
+    userErrors?: readonly UserError[];
+}
+export declare class TetherError extends Error {
+    name: "TetherError";
+    code: TetherErrorCode;
+    status: number | undefined;
+    errors: GraphQLError[] | undefined;
+    userErrors: readonly UserError[] | undefined;
+    constructor(message: string, { status, errors, userErrors, code }?: TetherErrorDetails);
+}
+/** What a request needs from a config: the browser's `cfg`, or a config the server helpers build. */
+export type StorefrontConfig = Pick<TetherConfig, 'domain' | 'token' | 'apiVersion' | 'country' | 'language' | 'maxAge' | 'retries'> & {
+    fetch?: typeof fetch;
+};
+/** Checks a query's `data` before its caller reads it as a `T`. */
+export type DataCheck<T> = (data: unknown) => data is T;
+/**
+ * The structure of JSON a check accepts: a `typeof` name, `'object'` for a plain object, `[item]` for a list of
+ * items, an object's fields, or a check of its own. Fields it doesn't name aren't checked, so a shape names only what
+ * its reader walks without a fallback.
+ */
+export type Shape = 'string' | 'number' | 'boolean' | 'object' | ((value: unknown) => boolean) | readonly [Shape] | {
+    readonly [key: string]: Shape;
+};
+/** @returns True when `value` has the structure `shape` describes. */
+export declare function matches(value: unknown, shape: Shape): boolean;
+/** @returns The shape of `null` or a value with the structure `shape` describes. */
+export declare const orNull: (shape: Shape) => (value: unknown) => boolean;
+/** @returns A check that `data` has the structure `shape` describes, which `T` states. */
+export declare const shaped: <T>(shape: Shape) => DataCheck<T>;
+/** `context: false` sends the query without `@inContext`. */
+interface RequestOptions {
+    context?: boolean;
+}
+/** What the store's token may read beyond the defaults. */
+export interface StoreAccess {
+    inventory: boolean;
+}
+/**
+ * A query's text, or a function that writes it for what the token may read: Tether's own queries, built from
+ * `fragments.ts`, leave out inventory for a token that can't read it.
+ */
+export type QueryText = string | ((access: StoreAccess) => string);
+/** @returns The Storefront GraphQL endpoint of `conf`'s store. */
+export declare function endpoint(conf?: Pick<TetherConfig, 'domain' | 'apiVersion'>): string;
+/**
+ * `inContext` for any country and language, as the public `Tether.withContext` takes them: one that isn't a valid
+ * code is left out, so page input never becomes query text.
+ */
+export declare function withContext(query: string, ctx?: {
+    country?: string | undefined;
+    language?: string | undefined;
+}): string;
+/**
+ * One Storefront API request, for any config: the browser's shared one (`gql`) or one the server helpers build.
+ * Queries carry a time bucket so Shopify's cache of an identical query text is at most `maxAge` seconds old. A query
+ * written for the store's access leaves out inventory once the token turns out not to read it (`INVENTORY_FIELD`);
+ * a fixed query text is the caller's own, and that refusal is its error.
+ *
+ * @param isData Checks that `data` has what the caller then reads, so a malformed answer fails here.
+ * @throws {TetherError} `NOT_CONFIGURED` without a domain or token, `NETWORK` when the store can't be reached,
+ *   `HTTP_<status>` for an HTTP or GraphQL failure, or for `data` that `isData` refuses.
+ */
+export declare function request<T>(conf: StorefrontConfig, query: QueryText, variables: Record<string, unknown>, isData: DataCheck<T>, { context }?: RequestOptions): Promise<T>;
+/** `request` with the browser's shared config. */
+export declare function gql<T>(query: QueryText, variables: Record<string, unknown>, isData: DataCheck<T>, options?: RequestOptions): Promise<T>;
+/** The check of `Tether.query()` and the server's `query()`, whose callers read `data` themselves. */
+export declare const hasData: (data: unknown) => data is object;
+/** `Tether.query()`: the caller's own query text decides the shape of `data`, and the caller's `T` states it. */
+export declare function query<T>(text: QueryText, variables?: Record<string, unknown>, options?: RequestOptions): Promise<T>;
+/**
+ * @param payload A mutation's payload.
+ * @param name The mutation, for the error message.
+ * @throws {TetherError} `ERROR` on an empty payload or on user errors (in `userErrors`).
+ */
+export declare function unwrap<Payload extends {
+    userErrors?: readonly UserError[] | null;
+}>(payload: Payload | null | undefined, name: string): Payload;
+export {};

package/dist/types/src/collection.d.ts

@@ -0,0 +1,25 @@
+import type { Product } from './fragments.js';
+import type { Collection, PageInfo, ProductQuery } from './loader.js';
+export declare const listSelector: () => string;
+export declare class ListScope {
+    readonly root: HTMLElement;
+    products: Product[];
+    pageInfo: PageInfo | null;
+    collection: Collection | null;
+    /** Counts loads, so only the latest one renders. */
+    loadToken: number;
+    constructor(root: HTMLElement);
+    $(selector: string): HTMLElement[];
+    /** The collection or search query of the list's attributes. */
+    options(): ProductQuery;
+    /**
+     * The product of a recommendations list: a handle, `url:…` (one dynamic product page), or empty inside a product
+     * scope for that product.
+     *
+     * @throws {TetherError} `NOT_FOUND` when there is no product to recommend for.
+     */
+    loadRecommendations(): Promise<Product[]>;
+    /** @param more Appends the next page instead of replacing the products. */
+    load(more?: boolean): Promise<void>;
+    render(): void;
+}