@occluze/tether 0.6.8 → 0.7.1

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

@@ -0,0 +1,85 @@
+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;
+/**
+ * @returns True when a change failed without saying whether Shopify applied it: no answer or no whole body came (the
+ *   network), a 2xx whose body isn't valid, or a server error (5xx), which can come after the change was committed.
+ *   Shopify's user errors and a 4xx are clear.
+ */
+export declare function isUnclearFailure(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,185 @@
+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. A stored value that isn't a cart id (written by another script,
+ * or edited by hand) is forgotten, so it is never sent to Shopify or the Worker and the next change starts a new cart.
+ */
+export declare function 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, savedCartId, 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: typeof savedCartId;
+    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,134 @@
+import type { TetherConfig } from './config.js';
+export type TetherErrorCode = 'NOT_FOUND' | 'NETWORK' | 'NOT_CONFIGURED' | 'NOT_LOGGED_IN' | 'INVALID' | 'INVALID_COUNTRY' | 'INVALID_DISCOUNT' | 'INVALID_RESPONSE' | '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?: readonly GraphQLError[];
+    /** A mutation's user errors. */
+    userErrors?: readonly UserError[];
+}
+export declare class TetherError extends Error {
+    readonly name: "TetherError";
+    readonly code: TetherErrorCode;
+    readonly status: number | undefined;
+    readonly errors: readonly GraphQLError[] | undefined;
+    readonly 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. A field's `undefined` is the type of one `ShapeOf` leaves out, and checks
+ * nothing.
+ */
+export type Shape = 'string' | 'number' | 'boolean' | 'object' | ((value: unknown) => boolean) | readonly [Shape] | {
+    readonly [key: string]: Shape | undefined;
+};
+/** @returns True when `value` has the structure `shape` describes. */
+export declare function matches(value: unknown, shape: Shape): boolean;
+/**
+ * The shapes that describe a `T`: every structure such a shape names is one `T` declares at that place, and a check
+ * in it is a type guard for a type `T` accepts there. A shape for `T` therefore can't name a field `T` lacks or claim
+ * a type `T` contradicts, so a change to `T` that its shape no longer agrees with fails to compile. Fields of `T` the
+ * shape doesn't name stay unchecked (`Shape`).
+ */
+export type ShapeOf<T> = unknown extends T ? Shape : KnownShapeOf<T>;
+type KnownShapeOf<T> = DataCheck<T> | (string extends T ? 'string' : never) | (number extends T ? 'number' : never) | (boolean extends T ? 'boolean' : never) | ListShapeOf<T> | FieldsShapeOf<T>;
+type ListShapeOf<T> = T extends readonly (infer Item)[] ? readonly [ShapeOf<Item>] : never;
+type FieldsShapeOf<T> = T extends readonly unknown[] ? never : T extends object ? 'object' | {
+    readonly [Key in keyof T]?: ShapeOf<T[Key]>;
+} : never;
+/** @returns A check that `value` is `null` or has the structure `shape` describes. */
+export declare const orNull: <T>(shape: ShapeOf<T>) => DataCheck<T | null>;
+/**
+ * @returns A check that `data` has the structure `shape` describes. `ShapeOf` ties `shape` to `T`; fields `shape`
+ *   doesn't name are `T`'s claim.
+ */
+export declare const shaped: <T>(shape: ShapeOf<T>) => DataCheck<T>;
+/**
+ * What an operation does to the store, which decides what is safe to retry. A query only reads, so a failure that may
+ * pass is retried: the network (no answer, or a body that stopped arriving), a 429, a 5xx and `THROTTLED`. Shopify may
+ * have applied a mutation before a 5xx or a dropped connection, so a mutation is retried only when Shopify answers
+ * that it didn't run it (429 or `THROTTLED`): sending it again could add a line twice. Other failures (a 4xx, a 430,
+ * an answer that isn't valid, other GraphQL errors) are never retried.
+ */
+export type Operation = 'query' | 'mutation';
+interface RequestOptions {
+    /** `false` sends the query without `@inContext`. */
+    context?: boolean;
+    /** Default `'query'`. */
+    operation?: Operation;
+}
+/** 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;
+/**
+ * The operation of a document Tether didn't write (`Tether.query()`, the server's `query()`). Outside strings and
+ * comments, any `mutation` keyword makes it a mutation: a document that starts with a fragment still has its
+ * operation found, and a misread errs on the side that is never sent twice.
+ */
+export declare function operationOf(document: string): Operation;
+/**
+ * `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. How often a failure is retried is
+ * `conf.retries`; which failures are retried is the operation's (`Operation`).
+ *
+ * @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 or
+ *   the answer's body stops arriving, `INVALID_RESPONSE` for a 2xx whose body isn't valid (not JSON, not in the
+ *   GraphQL shape, or `data` that `isData` refuses), `HTTP_<status>` for any other HTTP or GraphQL failure.
+ */
+export declare function request<T>(conf: StorefrontConfig, query: QueryText, variables: Record<string, unknown>, isData: DataCheck<T>, { context, operation }?: 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?: Omit<RequestOptions, 'operation'>): 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;
+}

package/dist/types/src/config-sections.d.ts

@@ -0,0 +1,40 @@
+import type { AccountConfig, AnalyticsConfig, MarketsConfig, MetafieldIdentifier, MetafieldRef } from './config.js';
+/** Warns that an option was dropped. */
+type Invalid = (name: string, value: unknown) => void;
+/** A host name, without protocol or path: what `domainOption` keeps of the `domain` option. */
+export type ShopDomain = string & {
+    readonly __brand: 'ShopDomain';
+};
+/** Every source `markets.detect` reads. */
+export declare const MARKET_SOURCES: readonly ('saved' | 'server' | 'webflow')[];
+/**
+ * @returns The store's domain without protocol or path (`https://shop.example/x` → `shop.example`), `''` for anything
+ *   that isn't a host name.
+ */
+export declare function domainOption(value: unknown, invalid: Invalid): ShopDomain | '';
+/**
+ * The folder of the optional parts. It must be https or on this site, which keeps parts off plain http (mixed content,
+ * rewritable on the way); it doesn't vouch for the host, which the site chose.
+ *
+ * @returns The folder as written, `null` for none or one elsewhere (the parts then load beside the core).
+ */
+export declare function partsUrlOption(value: unknown, invalid: Invalid): string | null;
+/**
+ * The origins a site lets description iframes load from. Each one is trusted to show only what the site expects in a
+ * description, so only a bare https origin is taken: a path would suggest a narrower trust than is given.
+ *
+ * @returns The valid origins; each other entry is skipped with a warning.
+ */
+export declare function embedOriginsOption(value: unknown, invalid: Invalid): string[];
+/** @returns The identifier of `'namespace.key'` or `{ namespace, key }`, when both parts are valid identifiers. */
+export declare function toMetafieldIdentifier(ref: unknown): MetafieldIdentifier | null;
+/** @returns The refs that name a valid identifier, as written; each other one is skipped with a warning. */
+export declare function metafieldsOption(value: unknown, invalid: Invalid): MetafieldRef[];
+/**
+ * @param warn Says why an `account` without a usable `server` is off.
+ * @returns `null` without a usable `account.server`: nothing of the account part loads.
+ */
+export declare function accountOption(value: unknown, invalid: Invalid, warn: (message: string) => void): AccountConfig | null;
+export declare const marketsOption: (value: unknown, invalid: Invalid) => MarketsConfig | null;
+export declare const analyticsOption: (value: unknown, invalid: Invalid) => AnalyticsConfig | null;
+export {};