@occluze/tether 0.6.8 → 0.7.0

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;
+}

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 {};

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

@@ -0,0 +1,185 @@
+export { MARKET_SOURCES } from './config-sections.js';
+import type { ApiVersion } from '../server/src/shared/api-versions.js';
+import type { ShopDomain } from './config-sections.js';
+import type { Money } from './shopify-values.js';
+import type { CountryCode, LanguageCode } from './market-codes.js';
+/** Where the visitor's market comes from (`markets.ts`). */
+export interface MarketsConfig {
+    /** True: every source; a list: only those. */
+    detect?: boolean | ('saved' | 'server' | 'webflow')[];
+    /** Webflow locale (subdirectory or html lang) to market. */
+    locales?: Record<string, {
+        country?: string;
+        language?: string;
+        locale?: string;
+    }>;
+    /** The cookie a server sets with the visitor's country. */
+    cookie?: string;
+    /** Remember the visitor's choice (default true). */
+    remember?: boolean;
+    /** With `locales`: ignore an html lang that isn't in the map. */
+    strict?: boolean;
+}
+/** The optional analytics part. */
+export interface AnalyticsConfig {
+    /** GA4/GTM events, into `window.dataLayer` or the named array. */
+    dataLayer?: boolean | string;
+    /** Shopify's own analytics. `proxy`: the site serves the Storefront API on its own domain. */
+    shopify?: boolean | {
+        consent?: 'no-banner' | 'default-banner' | 'custom-banner';
+        proxy?: boolean;
+    };
+    onEvent?: (name: string, data: Record<string, unknown>) => void;
+}
+/** The optional customer accounts part, which runs through the site's Worker. */
+export interface AccountConfig {
+    /** The Worker's account routes, a URL or a path on this site. */
+    server: string;
+    /** The site's own order page, with `{id}` for the numeric order id. */
+    orderUrl?: string;
+    /** Shopify's subscription management page. */
+    subscriptionsUrl?: string;
+    /** A separate page for payment methods (default `subscriptionsUrl`). */
+    paymentUrl?: string;
+    /** Where Shopify sends the visitor after logout (default the home page). */
+    logoutUrl?: string;
+    /** The language of Shopify's login pages. */
+    locale?: string;
+    /** Replaces `location.assign` for the login redirect (popups, tests). */
+    navigate?: (url: string) => void;
+}
+export interface MetafieldIdentifier {
+    namespace: string;
+    key: string;
+}
+/** `'namespace.key'` or the identifier itself. */
+export type MetafieldRef = string | MetafieldIdentifier;
+/** Shopify's note on a cart change. */
+export interface CartWarning {
+    code: string;
+    message: string;
+    target?: string;
+}
+export type CheckoutTarget = '_self' | '_blank';
+type PurchaseKind = 'one-time' | 'subscription';
+/** Every option, with its default filled in. */
+export interface TetherConfig {
+    /** The store's domain, without protocol or path; `''` until one is set. */
+    domain: ShopDomain | '';
+    /** The public Storefront API access token. */
+    token: string;
+    /** A dated Shopify API version (or `unstable`, with a warning). */
+    apiVersion: ApiVersion | 'unstable';
+    /** The market's country, for `@inContext(country:)`. */
+    country: CountryCode | undefined;
+    /** The market's language, for `@inContext(language:)`. */
+    language: LanguageCode | undefined;
+    /** An `Intl` locale for money and dates. */
+    locale: string | undefined;
+    markets: MarketsConfig | null;
+    /** The attribute prefix: `tether` reads `tether-product`, `tether-bind`. */
+    prefix: string;
+    /** A folder (`/product`) or a template with `{handle}` / `{id}`. */
+    productPath: string;
+    collectionPath: string;
+    /** The product metafields to fetch. */
+    metafields: MetafieldRef[];
+    /** Origins (`https://video.example`) a description's iframes may load from, besides the built-in video players. */
+    embedOrigins: string[];
+    imagesFirst: number;
+    variantsFirst: number;
+    sellingPlanGroupsFirst: number;
+    sellingPlansFirst: number;
+    collectionFirst: number;
+    /** Retries of a request that failed on the network, a 429/5xx or Shopify's throttling. */
+    retries: number;
+    /** Refresh server-rendered products once in the background. */
+    revalidate: boolean;
+    /** The localStorage key of the cart id (default `<prefix>:cart:<domain>`). */
+    storageKey: string;
+    cartDrawerOpenClass: string;
+    openCartOnAdd: boolean;
+    /** Move focus into the open cart, keep Tab inside it, restore it on close. */
+    cartFocus: boolean;
+    checkoutTarget: CheckoutTarget;
+    defaultPurchase: PurchaseKind;
+    /** `?variant=` follows the visitor's choice on the page's main product. */
+    variantUrl: boolean;
+    /** Seconds a Shopify answer may be cached; 0 leaves it to Shopify, which can be hours. */
+    maxAge: number;
+    /** `tether-show="low-stock"` at this many or fewer (needs inventory access). */
+    lowStock: number;
+    /** Milliseconds the search part waits after the last keystroke. */
+    searchDelay: number;
+    /** Mount the document on DOMContentLoaded. */
+    autoMount: boolean;
+    /** Mount elements added later (CMS load more, filters). */
+    observe: boolean;
+    /** Mount on Astro's `astro:page-load` and close the cart on navigation. */
+    astro: boolean;
+    /** The folder of the optional parts, for the `<script>` build. */
+    partsUrl: string | null;
+    analytics: AnalyticsConfig | null;
+    account: AccountConfig | null;
+    /** The site's text for a cart warning; nothing keeps Shopify's. */
+    warningText: ((warning: CartWarning) => string | null | undefined) | null;
+    formatMoney: ((money: Money, locale: string | undefined) => string) | null;
+    /** Default: `ScrollTrigger.refresh()` when present. */
+    onLayoutChange: ((reason: string) => void) | null;
+    onCartOpen: ((drawers: HTMLElement[]) => void) | null;
+    onCartClose: ((drawers: HTMLElement[]) => void) | null;
+    onLineEnter: ((node: HTMLElement) => void) | null;
+    /** Animates a line out, then calls `done()`. */
+    onLineLeave: ((node: HTMLElement, done: () => void) => void) | null;
+    onValueChange: ((element: HTMLElement, previousText: string) => void) | null;
+    /** Every failure that reaches the visitor. */
+    onError: ((error: unknown, context: string) => void) | null;
+    debug: boolean;
+}
+/** The options a site writes as plain text, which `resolveConfig` checks into their typed form. */
+type ParsedFromText = 'domain' | 'apiVersion' | 'country' | 'language' | 'storageKey';
+/**
+ * What a site passes: any option, the market as the codes people write (`'de'`, `'pt-BR'`), and `null` for the
+ * default storage key.
+ */
+export type TetherOptions = {
+    [Key in Exclude<keyof TetherConfig, ParsedFromText>]?: TetherConfig[Key];
+} & Partial<Record<Exclude<ParsedFromText, 'storageKey'>, string | undefined>> & {
+    storageKey?: string | null | undefined;
+};
+export declare const DEFAULTS: Readonly<TetherConfig>;
+export declare const cfg: TetherConfig;
+/**
+ * `cfg` as `Tether.config` shows it. A value written there would skip the validation `configure()` does, so the view
+ * is read-only; `Tether.init(options)` is how a site changes the config.
+ */
+export declare const configView: TetherConfig;
+/**
+ * The configuration `options` describe: defaults filled in, every value validated (an invalid one warns and falls
+ * back to its default), hooks that aren't functions dropped so callers only check for null.
+ *
+ * @param options What the site set, or any object (the server helpers take their options from code and `.env`).
+ */
+export declare function resolveConfig(options: TetherOptions | Readonly<Record<string, unknown>>): TetherConfig;
+/**
+ * @param value A `markets` option from code other than the config (`Tether.detectMarket(markets)`).
+ * @returns It validated as the config's own is, with the same warnings.
+ */
+export declare const parseMarkets: (value: unknown) => MarketsConfig | null;
+/**
+ * Replaces the shared configuration with `options` over the defaults (see `resolveConfig`).
+ *
+ * @returns The shared `cfg`.
+ */
+export declare function configure(options?: TetherOptions | Readonly<Record<string, unknown>>): TetherConfig;
+/** @returns True once a domain and a token are set. */
+export declare const isConfigured: () => boolean;
+export declare function log(...args: unknown[]): void;
+export declare function warn(...args: unknown[]): void;
+/**
+ * Logs a failure that reaches the visitor and hands it to `onError`. A throwing `onError` is logged, never rethrown:
+ * the site's hook must not break the render that reported the failure.
+ *
+ * @param context What failed, e.g. `product coffee-box`.
+ */
+export declare function reportError(error: unknown, context: string): void;

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

@@ -0,0 +1,2 @@
+/** Binds the document-wide listeners, once per page load of the script. */
+export declare function bindCartControls(): void;

package/dist/types/src/controls/discount.d.ts

@@ -0,0 +1,2 @@
+/** Binds the document-wide listeners, once per page load of the script. */
+export declare function bindDiscountControls(): void;

package/dist/types/src/controls/extras.d.ts

@@ -0,0 +1,5 @@
+import type { ShopifyCart } from '../cart/store.js';
+/** `[tether-group]` with `[tether-group-add]`: adds every product scope inside the group in one request. */
+export declare const addGroup: (button: Element) => Promise<ShopifyCart | null>;
+/** Binds the document-wide listeners, once per page load of the script. */
+export declare function bindExtrasControls(): void;