@occluze/tether 0.6.7 → 0.7.0

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

@@ -0,0 +1,167 @@
+/// <reference path="./globals.d.ts" />
+import { query, TetherError, withContext } from './client.js';
+import { getProduct, getProducts, getRecommendations, clearProductCache, primeProduct } from './loader.js';
+import * as plans from './selling-plans.js';
+import { resolveProductKey } from './status.js';
+import { formatMoney, imageUrl } from './dom.js';
+import { setCountry } from './page-market.js';
+import { addGroup } from './controls/extras.js';
+import type { TetherConfig, TetherOptions, MarketsConfig } from './config.js';
+import type { ShopifyCart } from './cart/store.js';
+import type { ProductScope } from './product.js';
+import type { DiagnoseOptions } from './diagnose.js';
+import type { TetherEvents } from './markup.js';
+export { addGroup, setCountry };
+export type { TetherOptions as TetherConfig, TetherConfig as ResolvedTetherConfig } from './config.js';
+export type { MarketsConfig, CartWarning } from './config.js';
+export type { Money } from './shopify-values.js';
+export type { Image as ShopifyImage, Metafield as ShopifyMetafield, Product as ShopifyProduct, ProductVariant as ShopifyVariant, SellingPlan as ShopifySellingPlanNode, SellingPlanAdjustmentValue, SellingPlanAllocation as ShopifySellingPlanAllocation, SellingPlanGroup as ShopifySellingPlanGroup, } from './fragments.js';
+export type { PlanInGroup as ShopifySellingPlan, PlanAdjustment, ProductWithPlans, VariantWithPlans, } from './selling-plans.js';
+export type { CartStatus, CartVariant as ShopifyCartVariant, ShopifyCart, ShopifyCartLine } from './cart/store.js';
+export type { Attributes, LineSpec as LineInput } from './cart/mutations.js';
+export type { TetherError, TetherErrorCode, GraphQLError, UserError } from './client.js';
+export type { ProductScope } from './product.js';
+export type { Purchase } from './product-state.js';
+export type { ProductPage, ProductQuery } from './loader.js';
+export type { DetectedMarket, Localization, MarketSource } from './markets.js';
+export type { SetCountryOptions } from './page-market.js';
+export type { DiagnoseOptions, DiagnoseReport } from './diagnose.js';
+export type { TetherEvents } from './markup.js';
+export type { AccountCustomer } from './account/answers.js';
+export type { AccountImage as ImageRef, AccountOrder, AccountOrderLine } from '../server/src/shared/account-orders.js';
+export type { AddressFields as CustomerAddressInput } from './account/operations.js';
+export type { CustomerAddress, Fulfillment, MailingAddress, OrderDetail, OrderDetailLine, SubscriptionContract, SubscriptionLine, } from './account/page-answers.js';
+/** The helpers for selling plans, `Tether.plans`. */
+export type SellingPlanHelpers = typeof plans;
+export declare const VERSION = "0.7.0";
+/**
+ * Mounts every product scope and product list inside `root`. Safe to call repeatedly.
+ *
+ * @returns The scopes and lists newly mounted.
+ */
+export declare function mount(root?: Document | Element): number;
+/** Call before a page transition removes the page: closes the cart drawer. */
+export declare function unmount(): void;
+/** @returns The product scope `el` is in. */
+export declare function getScope(el: Element | null | undefined): ProductScope | null;
+/**
+ * Configures Tether (`window.TETHER_CONFIG` with `overrides` over it), applies the visitor's market and loads the
+ * cart. A second call without overrides returns the first one's promise.
+ *
+ * @returns `null` without a domain and token, when Tether stays idle.
+ */
+export declare function init(overrides?: TetherOptions): Promise<Tether | null>;
+/**
+ * Listens to the Tether event `<prefix>:<name>`. Only the events Tether dispatched reach the listener: one another
+ * script dispatches under the same name is ignored, so the detail is always the one `TetherEvents` gives.
+ *
+ * @returns Stops listening.
+ */
+declare function on<Name extends keyof TetherEvents>(name: Name, listener: (detail: TetherEvents[Name], event: CustomEvent<TetherEvents[Name]>) => void): () => void;
+declare const publicApi: {
+    VERSION: string;
+    init: typeof init;
+    mount: typeof mount;
+    unmount: typeof unmount;
+    /** The live config, read-only. */
+    readonly config: Readonly<TetherConfig>;
+    readonly ready: Promise<Tether | null>;
+    query: typeof query;
+    withContext: typeof withContext;
+    cart: {
+        init: () => Promise<ShopifyCart | null>;
+        id: () => string | null;
+        readonly status: import("./cart/store.js").CartStatus;
+        readonly state: ShopifyCart | null;
+        readonly lines: import("./cart/store.js").ShopifyCartLine[];
+        readonly count: number;
+        readonly loaded: boolean;
+        readonly lastError: Error | null;
+        readonly warnings: import("./config.js").CartWarning[];
+        readonly pendingQty: ReadonlyMap<string, {
+            quantity: number;
+        }>;
+        setCheckoutResolver: typeof import("./cart/checkout.js").setCheckoutResolver;
+        forgetSaved(): void;
+        render: typeof import("./cart/store.js").render;
+        subscribe: typeof import("./cart/store.js").subscribe;
+        add(input: string | number | import("./cart/mutations.js").LineSpec | (string | number | import("./cart/mutations.js").LineSpec)[], quantity?: number, options?: Omit<import("./cart/mutations.js").LineSpec, "variantId" | "quantity">): Promise<ShopifyCart>;
+        updateLine(lineId: string, patch: number | import("./cart/mutations.js").LinePatch): Promise<ShopifyCart | null>;
+        changeQuantity: (lineId: string, delta: number) => Promise<ShopifyCart | null>;
+        quantityOf: (line: import("./cart/store.js").ShopifyCartLine) => number;
+        removeLine(lineIds: string | string[]): Promise<ShopifyCart | null>;
+        clear(): Promise<ShopifyCart | null>;
+        setNote(note: string | null | undefined): Promise<ShopifyCart | null>;
+        setAttributes(attributes: import("./cart/mutations.js").Attributes): Promise<ShopifyCart | null>;
+        setDiscountCodes(codes: string | string[] | ((current: string[]) => string[])): Promise<ShopifyCart | null>;
+        applyDiscount(code: string): Promise<ShopifyCart | null>;
+        removeDiscount(code: string): Promise<ShopifyCart | null>;
+        setBuyerIdentity(buyerIdentity: {
+            countryCode?: string;
+            email?: string;
+            phone?: string;
+        }, { create }?: {
+            create?: boolean;
+        }): Promise<ShopifyCart | null>;
+        checkout: typeof import("./cart/checkout.js").checkout;
+        drawers: () => HTMLElement[];
+        isOpen: typeof import("./cart/drawer.js").isOpen;
+        open: typeof import("./cart/drawer.js").openCart;
+        close: typeof import("./cart/drawer.js").closeCart;
+        toggle: typeof import("./cart/drawer.js").toggleCart;
+    };
+    getProduct: typeof getProduct;
+    getProducts: typeof getProducts;
+    getRecommendations: typeof getRecommendations;
+    getScope: typeof getScope;
+    addGroup: (button: Element) => Promise<ShopifyCart | null>;
+    account: {
+        login: (args_0?: {
+            returnTo?: string;
+            locale?: string;
+        } | undefined) => Promise<void>;
+        customer: () => Promise<import("./account/answers.js").AccountCustomer | null>;
+        orders: (args_0?: {
+            first?: number;
+        } | undefined) => Promise<import("../server/src/shared/account-orders.js").AccountOrder[]>;
+        logout: (args_0?: {
+            returnTo?: string;
+        } | undefined) => Promise<void>;
+        render: (root?: ParentNode | undefined) => Promise<void>;
+        mountAccount: (root?: ParentNode | undefined) => Promise<void>;
+        readonly isLoggedIn: () => Promise<boolean>;
+        readonly order: (id: string | number) => Promise<import("./account/page-answers.js").OrderDetail | null>;
+        readonly updateProfile: (fields?: {
+            firstName?: string;
+            lastName?: string;
+        }) => Promise<import("./account/page-answers.js").Profile>;
+        readonly addresses: () => Promise<import("./account/page-answers.js").CustomerAddress[]>;
+        readonly saveAddress: (address: import("./account/operations.js").AddressFields | null, options?: {
+            id?: string;
+            isDefault?: boolean;
+        }) => Promise<import("./account/page-answers.js").AccountAddress>;
+        readonly deleteAddress: (id: string) => Promise<string>;
+        readonly subscriptions: () => Promise<import("./account/page-answers.js").SubscriptionContract[]>;
+        readonly subscriptionAction: (id: string | number, action: import("../server/src/shared/account-routes.js").SubscriptionAction) => Promise<import("./account/page-answers.js").SubscriptionChange>;
+        readonly requestReturn: (orderId: string | number, lines: import("./account/operations.js").ReturnLine[]) => Promise<import("./account/page-answers.js").OpenedReturn>;
+    };
+    primeProduct: typeof primeProduct;
+    normalizeProductKey: typeof import("./shopify-values.js").productKey;
+    clearProductCache: typeof clearProductCache;
+    formatMoney: typeof formatMoney;
+    imageUrl: typeof imageUrl;
+    plans: typeof plans;
+    TetherError: typeof TetherError;
+    resolveProductKey: typeof resolveProductKey;
+    setCountry: typeof setCountry;
+    detectMarket: (markets?: MarketsConfig | null) => Promise<import("./markets.js").DetectedMarket>;
+    getLocalization: () => Promise<import("./markets.js").Localization>;
+    diagnose: (options?: Omit<DiagnoseOptions, "version">) => Promise<import("./diagnose.js").DiagnoseReport>;
+    on: typeof on;
+};
+/** `window.Tether`, and what `import Tether from '@occluze/tether'` gives. */
+export type Tether = typeof publicApi;
+/** `Tether`, also carrying `TetherInternals`, which the published type leaves out. */
+export declare const api: Tether;
+/** @alias `api`, for `import Tether from '@occluze/tether'`. */
+export default api;

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

@@ -0,0 +1,56 @@
+import type { Money } from './shopify-values.js';
+import type { Product, ProductVariant } from './fragments.js';
+import type { PlanInGroup } from './selling-plans.js';
+import type { Selection, ShowCondition } from './product-state.js';
+export interface InitialOptions {
+    /** The page's `?variant=`; the first variant for sale without. */
+    variant?: string | null | undefined;
+    /** The page's `?selling_plan=`: subscribes on that plan. */
+    sellingPlan?: string | null | undefined;
+    /** `subscription` subscribes on the first plan. */
+    defaultPurchase?: string | null | undefined;
+    /** `low-stock` at this many or fewer. */
+    lowStock?: number | undefined;
+}
+/** A plan in the plan list (`tether-plan-list`). */
+interface InitialPlan {
+    id: string;
+    name: string;
+    /** On this plan, for the variant. */
+    price: Money | null;
+    /** In %, 0 without savings. */
+    savings: number;
+    /** `is-selected`: the line is bought on this plan. */
+    selected: boolean;
+    /** The variant is on this plan; `is-unavailable` when not. */
+    available: boolean;
+}
+export interface InitialState {
+    variant: ProductVariant;
+    /** Option name → value of the variant: `is-selected` on those buttons. */
+    selected: Selection;
+    purchase: 'one-time' | 'subscription';
+    /** The plan the line is bought on, `null` when bought once. */
+    plan: PlanInGroup | null;
+    plans: InitialPlan[];
+    /** The offered plan's savings in % (`tether-bind="subscription-savings"`), 0 without. */
+    savings: number;
+    price: Money;
+    /** Only when on sale. */
+    compareAtPrice: Money | null;
+    available: boolean;
+    /** The `tether-show` conditions: `hidden={!state.show['out-of-stock']}`. */
+    show: Record<ShowCondition, boolean>;
+    /**
+     * Per option, the values without a variant for sale (given the other selected values), as plain data for
+     * frameworks that serialise props.
+     */
+    unavailable: Record<string, string[]>;
+    /** The same as a function: `is-unavailable`. */
+    isUnavailable: (name: string, value: string) => boolean;
+}
+/** @throws TetherError For a product without variants, which Shopify never sends: every product has one. */
+export declare function initialState(product: Product, options?: InitialOptions): InitialState;
+/** @returns `null` without a product. */
+export declare function initialState(product: Product | null | undefined, options?: InitialOptions): InitialState | null;
+export {};

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

@@ -0,0 +1,28 @@
+/**
+ * Optional parts that most pages never need, loaded on first use. In the ESM and Node builds they are dynamic
+ * imports, which bundlers split into their own chunks; the `<script>` build swaps this file for `lazy-iife.ts`
+ * (scripts/build.ts).
+ */
+export interface Parts {
+    diagnose: typeof import('./diagnose.js');
+    markets: typeof import('./markets-ui.js');
+    search: typeof import('./search.js');
+    extras: typeof import('./extras.js');
+    account: typeof import('./account.js');
+    'account-pages': typeof import('./account-pages.js');
+    analytics: typeof import('./analytics.js');
+}
+export type PartName = keyof Parts;
+/**
+ * What `window.Tether` carries for the `<script>` build's separately loaded parts, besides the API sites use. Left out
+ * of the published `Tether` type.
+ */
+export interface TetherInternals {
+    /** `coreModules`: the modules the parts use instead of bundling copies, in the `<script>` build only. */
+    __core: unknown;
+    /** Each part registers its module here when its file has loaded. */
+    __parts: Partial<Parts>;
+}
+export declare const loadPart: <Name extends PartName>(name: Name) => Promise<Parts[Name]>;
+/** Only the `<script>` build shares its modules with separately loaded parts. */
+export declare const coreModules: undefined;

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

@@ -0,0 +1,84 @@
+import { productKey } from './shopify-values.js';
+import type { Product, Image } from './fragments.js';
+import type { ProductConnection } from './product-shape.js';
+/** Accepts a handle, numeric id, gid or a full product URL. */
+export declare const normalizeProductKey: typeof productKey;
+/** Puts a product the page already has (from a collection query) in the cache, under its handle and its id. */
+export declare function primeProduct(product: Product | null | undefined): void;
+/**
+ * @param rawKey A handle, numeric id, gid or product URL.
+ * @throws {TetherError} `NOT_FOUND` (rejected) for an empty key or a product the store doesn't have.
+ */
+export declare function getProduct(rawKey: string | number | null | undefined): Promise<Product>;
+/** Forgets every product, for a new market: requests already sent no longer fill the cache. */
+export declare function clearProductCache(): void;
+/**
+ * Uses products the server rendered, unless the page loaded the same product live in the last `FRESH_MS` (an earlier
+ * page of a View Transition visit), whose copy is newer.
+ */
+export declare function hydrateProducts(products: readonly Product[] | null | undefined): void;
+/** @returns True once per server-rendered product: the caller then refreshes it. */
+export declare function takeStale(rawKey: string | number | null | undefined): boolean;
+/** Loads this product again, past the cache. Products refreshed in the same tick go out as one request. */
+export declare function refreshProduct(key: string | number): Promise<Product>;
+export interface PageInfo {
+    hasNextPage: boolean;
+    endCursor: string | null;
+}
+export interface Collection {
+    id: string;
+    handle: string;
+    title: string;
+    description: string;
+    descriptionHtml: string;
+    image: Image | null;
+    seo: {
+        title: string | null;
+        description: string | null;
+    };
+}
+export interface ProductPage {
+    collection: Collection | null;
+    products: Product[];
+    pageInfo: PageInfo;
+}
+export interface ProductQuery {
+    /** A collection handle; without one, a search. */
+    collection?: string;
+    /** Storefront search syntax, for a search. */
+    query?: string;
+    first?: number;
+    /** The cursor of the page before. */
+    after?: string | null;
+    /** `ProductCollectionSortKeys` for a collection, `ProductSortKeys` for a search. */
+    sortKey?: string;
+    reverse?: boolean;
+    /** `ProductFilter` values, for a collection. */
+    filters?: unknown[];
+}
+/** A collection's answer: `null` for a handle the store doesn't have. Its other fields are written as text. */
+export declare const isCollectionAnswer: import("./client.js").DataCheck<{
+    collection: (Collection & {
+        products: ProductConnection;
+    }) | null;
+}>;
+export declare const isSearchAnswer: import("./client.js").DataCheck<{
+    products: ProductConnection;
+}>;
+export declare const isRecommendationsAnswer: import("./client.js").DataCheck<{
+    productRecommendations: Product[] | null;
+}>;
+/**
+ * A page of products from a collection (by handle) or from a search. Every product on it is cached.
+ *
+ * @throws {TetherError} `NOT_FOUND` for a collection the store doesn't have.
+ */
+export declare function getProducts({ collection, query, first, after, sortKey, reverse, filters, }?: ProductQuery): Promise<ProductPage>;
+/**
+ * Shopify's recommendations for a product. Every product in them is cached.
+ *
+ * @param product A product, or its handle, id or gid.
+ */
+export declare function getRecommendations(product: string | number | {
+    id: string;
+} | null | undefined, intent?: 'RELATED' | 'COMPLEMENTARY'): Promise<Product[]>;

package/dist/types/src/market-codes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Country and language codes as Shopify's `@inContext` takes them, parsed by the module the Worker uses for the
+ * login's market, so the browser and the Worker accept and refuse the same values.
+ */
+export { toCountry, toLanguage } from '../server/src/shared/market-codes.js';
+export type { CountryCode, LanguageCode } from '../server/src/shared/market-codes.js';

package/dist/types/src/markets-ui.d.ts

@@ -0,0 +1,32 @@
+import { Cart } from './cart.js';
+import type { Localization } from './markets.js';
+export { detectMarket } from './markets.js';
+/**
+ * The countries the store sells to (Shopify Markets), with their currency. Cached per page; a failed request is not
+ * cached, so the next call tries again.
+ */
+export declare function getLocalization(): Promise<Localization>;
+interface SetCountryOptions {
+    /** A Shopify language; `null` clears it. Default: the `markets.locales` entry for the country, else unchanged. */
+    language?: string | null | undefined;
+    /** The money format. Default: the `markets.locales` entry, else unchanged. */
+    locale?: string | undefined;
+    /** Save the choice for the next pages (default true). */
+    remember?: boolean | undefined;
+}
+/**
+ * Fills `select[tether-country-select]` with the countries the store sells to (Shopify Markets), and
+ * `tether-country-bind="name|code|currency|symbol"` with the current country. `tether-country-label` sets the option
+ * text from `{name}`, `{code}`, `{currency}` and `{symbol}`. A failure is reported, never thrown.
+ */
+export declare function renderCountrySelects(root?: ParentNode): Promise<void>;
+/**
+ * Switches the market: prices, currency and translations follow (`@inContext`), the cart's
+ * `buyerIdentity.countryCode` is updated, and every product and list on the page re-renders.
+ *
+ *   Tether.setCountry('DE')            Tether.setCountry('BE', { language: 'FR' })
+ *
+ * @returns The cart once everything is in the new market.
+ * @throws {TetherError} `INVALID_COUNTRY` for anything that isn't a country code.
+ */
+export declare function setCountry(code: string, { language, locale, remember }?: SetCountryOptions): Promise<typeof Cart.state>;

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

@@ -0,0 +1,72 @@
+import type { MarketsConfig } from './config.js';
+import type { CountryCode, LanguageCode } from './market-codes.js';
+/** A market a visitor chose, as `setCountry()` stores it. */
+export interface Market {
+    country: CountryCode;
+    language: LanguageCode | undefined;
+    /** An `Intl` locale for money and dates. */
+    locale: string | undefined;
+}
+export type MarketSource = 'saved' | 'server' | 'webflow';
+type MarketField = 'country' | 'language' | 'locale';
+type MarketSources = Partial<Record<MarketField, MarketSource>>;
+/** The fields detection found, and the source each came from. */
+export interface DetectedMarket {
+    country?: CountryCode;
+    language?: LanguageCode;
+    locale?: string;
+    /** Absent when `detect: false` turns detection off. */
+    sources?: MarketSources;
+}
+/** What detection reads, passed in so it runs on any document. */
+interface MarketEnv {
+    document: Pick<Document, 'cookie' | 'querySelector' | 'documentElement'> | null;
+    location: Pick<Location, 'pathname'> | null;
+    /** `localStorage`, read through `getStored`, which finds nothing where the browser blocks it. */
+    storage: Pick<Storage, 'getItem'>;
+    /** Where `TETHER_COUNTRY` and `TETHER_LANGUAGE` are read from (`window`). */
+    global: object;
+}
+interface NamedCode {
+    isoCode: string;
+    name: string;
+}
+interface Currency {
+    isoCode: string;
+    symbol: string;
+}
+export type LocalizedCountry = NamedCode & {
+    currency: Currency;
+};
+/** The store's markets, from the Storefront API's `localization`. */
+export interface Localization {
+    /** The country of the current `@inContext`. */
+    country: LocalizedCountry;
+    language: NamedCode;
+    availableCountries: (LocalizedCountry & {
+        availableLanguages: NamedCode[];
+    })[];
+}
+/** The localStorage key of the visitor's market: `<prefix>:market:<domain>`. */
+export declare const storageKey: () => string;
+/**
+ * The visitor's saved market (`setCountry()`, `tether-country-select`), validated: storage is written by other tabs,
+ * older versions and other scripts too.
+ *
+ * @param storage Default `localStorage`.
+ * @returns `null` when nothing valid is saved.
+ */
+export declare function readSavedMarket(storage?: Pick<Storage, 'getItem'>): Market | null;
+/**
+ * The market the page's sources point to. Reads the DOM and storage only, so it can run on any `env`.
+ *
+ * @returns Only the fields found; `{}` with `detect: false`.
+ */
+export declare function detectMarket(markets?: MarketsConfig | null | undefined, env?: MarketEnv): DetectedMarket;
+/** Saves the visitor's choice for the next pages, unless `markets.remember` is false. */
+export declare function rememberMarket(market: {
+    country: CountryCode;
+    language?: string | null | undefined;
+    locale?: string | null | undefined;
+}): void;
+export {};

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

@@ -0,0 +1,131 @@
+import type { ShopifyCart } from './cart/store.js';
+import type { CartLineInput } from './cart/mutations.js';
+import type { CartWarning } from './config.js';
+import type { Product, ProductVariant } from './fragments.js';
+import type { Collection } from './loader.js';
+import type { ProductScope } from './product.js';
+import type { Purchase } from './product-state.js';
+import type { SearchResults } from './search.js';
+/** @returns The prefixed attribute name: `product` → `tether-product`. */
+export declare const attr: (name: string) => string;
+/** @returns A selector for the attribute, with that exact value when given. */
+export declare const sel: (name: string, value?: string) => string;
+export declare const get: (el: Element, name: string) => string | null;
+export declare const has: (el: Element, name: string) => boolean;
+/**
+ * Tether's attributes go on HTML elements, so matches are typed as such. An SVG element that carries one still has
+ * the `style`, `dataset` and attribute methods Tether uses.
+ *
+ * @returns The matches in `root`, none without a root.
+ */
+export declare function qsa(root: ParentNode | null | undefined, selector: string): HTMLElement[];
+/** @returns Matches in `root` whose nearest `scopeSelector` ancestor is `root` itself, not a nested scope. */
+export declare const scoped: (root: Element | null | undefined, selector: string, scopeSelector: string) => HTMLElement[];
+/**
+ * The events Tether dispatches, as `<prefix>:<name>` (`tether:cart-updated`), bubbling up to `document`, with the
+ * detail each carries. `emit` takes only these, and `Tether.on()` passes on only the events `emit` dispatched, so a listener gets the
+ * detail its event really has.
+ */
+export interface TetherEvents {
+    ready: {
+        cart: ShopifyCart | null;
+    };
+    'product-ready': {
+        product: Product;
+        scope: ProductScope;
+    };
+    'product-updated': {
+        product: Product;
+        scope: ProductScope;
+    };
+    /** `key` is null when the scope names no product; `source` is what it named. */
+    'product-not-found': {
+        key: string | null;
+        source: string;
+    };
+    'variant-changed': {
+        product: Product;
+        variant: ProductVariant;
+        selected: Record<string, string>;
+        purchase: Purchase['kind'];
+        sellingPlanId: string | null;
+    };
+    'product-added': {
+        product: Product;
+        variant: ProductVariant;
+        line: CartLineInput;
+    };
+    added: {
+        cart: ShopifyCart;
+        lines: CartLineInput[];
+    };
+    'group-added': {
+        group: string | null;
+        lines: CartLineInput[];
+    };
+    'cart-warning': {
+        warnings: readonly CartWarning[];
+    };
+    'cart-updated': {
+        cart: ShopifyCart | null;
+        reason: string;
+    };
+    'cart-toggled': {
+        open: boolean;
+    };
+    'cart-error': {
+        error: unknown;
+    };
+    checkout: {
+        url: string;
+        cart: ShopifyCart | null;
+    };
+    'list-ready': {
+        products: Product[];
+        collection: Collection | null;
+    };
+    /** A list's cards were drawn (again): `container` holds them. */
+    'list-rendered': {
+        container: Element;
+    };
+    /** The search part's suggestions for `term`. */
+    search: SearchResults & {
+        term: string;
+    };
+    'country-changed': {
+        country: string;
+        language: string | undefined;
+    };
+    'discount-applied': {
+        code: string;
+    };
+    'discount-invalid': {
+        code: string;
+    };
+    'layout-changed': {
+        reason: string;
+    };
+    error: {
+        error: unknown;
+        context: string;
+        key?: string | null;
+    };
+    'account-login': Record<string, never>;
+    'account-logout': Record<string, never>;
+    /** A login that failed: `expired` (it took too long, or came back to another browser) or `error`. */
+    'account-error': {
+        error: 'expired' | 'error';
+    };
+    'account-updated': {
+        what: 'profile' | 'addresses' | 'subscriptions' | 'orders';
+    };
+}
+/** The events the analytics part reports, which the core buffers from `init()` until the part has loaded. */
+export declare const ANALYTICS_EVENTS: readonly ["product-ready", "list-ready", "cart-updated", "cart-toggled", "checkout", "search"];
+export type AnalyticsEventName = (typeof ANALYTICS_EVENTS)[number];
+/** @returns The bubbling event `<prefix>:<name>`, known to `isOwnEvent`. */
+export declare function ownEvent<Name extends keyof TetherEvents>(name: Name, detail: TetherEvents[Name]): CustomEvent<TetherEvents[Name]>;
+/** @returns True for an event `ownEvent` created as `name`, false for any other, such as one another script dispatched. */
+export declare function isOwnEvent<Name extends keyof TetherEvents>(event: Event, name: Name): event is CustomEvent<TetherEvents[Name]>;
+/** Dispatches the bubbling event `<prefix>:<name>`. */
+export declare function emit<Name extends keyof TetherEvents>(name: Name, detail: TetherEvents[Name], target?: EventTarget): void;

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

@@ -0,0 +1,46 @@
+/** A mounted `ListScope`. */
+interface MountedList {
+    root: Element;
+    load: (more?: boolean) => Promise<unknown>;
+}
+export declare const mountedProducts: WeakSet<Element>;
+export declare const mountedLists: WeakSet<Element>;
+/** Product roots to re-render after a country switch; pruned once disconnected. */
+export declare const liveProducts: Set<HTMLElement>;
+/** Lists to reload after a country switch; pruned once disconnected. */
+export declare const liveLists: Set<MountedList>;
+/** Forgets roots a page transition removed, so they aren't kept alive. */
+export declare function pruneLive(): void;
+/** @returns `root` itself when it matches, then the matches inside it. */
+export declare function within(root: ParentNode & Partial<Pick<Element, 'matches'>>, selector: string): HTMLElement[];
+/**
+ * Mounts one product root.
+ *
+ * @returns True when a product request was started.
+ */
+export declare function mountProduct(el: HTMLElement): boolean;
+/** Loads again the product scopes that failed on a network or API error, for when the browser is back online. */
+export declare function retryFailed(): void;
+/**
+ * Lists, and anything else that loads prices, hold `html.tether-market-pending` until they are in.
+ *
+ * @returns `loading` itself.
+ */
+export declare const trackMarket: <T>(loading: Promise<T>) => Promise<T>;
+/** After a mount: drops `html.tether-market-pending` once this page's products are live. */
+export declare function settleMarket(): void;
+/**
+ * Uses the products in the page's hydrate tags (`tether/server` `hydrate()`) without a request. A tag made for another
+ * market is skipped, and marks the page (`html.tether-market-pending`) until the live prices are in, so CSS can hide
+ * prices meanwhile.
+ *
+ * Trust: a hydrate tag is part of the page, written by the site's own build like the rest of its HTML and scripts, so
+ * its prices and products are shown until the background refresh replaces them. Whoever can write a tag into the page
+ * can already write a script there; the shape check (`isProductShape`) is for a truncated or hand-written tag, which
+ * is skipped instead of failing a render.
+ *
+ * @param root Where to look: the document for a mount (a tag may sit in `<head>` or anywhere else on the page), the
+ *   added elements for `observe`.
+ */
+export declare function hydrateFromPage(root?: Document | Element): void;
+export {};

package/dist/types/src/page-market.d.ts

@@ -0,0 +1,27 @@
+import type { TetherOptions } from './config.js';
+import type { Parts } from './lazy.js';
+import type { ShopifyCart } from './cart/store.js';
+export type SetCountryOptions = Parameters<Parts['markets']['setCountry']>[1];
+/**
+ * Sets `cfg`'s market for the first page, over the configured one.
+ *
+ * @param overrides What `init()` was called with: a `locale` there wins over the visitor's.
+ */
+export declare function applyStartMarket(overrides: TetherOptions): Promise<void>;
+/**
+ * The market to switch to on arriving at the current page. A page built for a market switches to it; the first page
+ * without one after such a page switches back to the visitor's own choice, else to the configured market.
+ *
+ * @returns `null` when the page stays in the market in use.
+ */
+export declare function marketForArrival(): {
+    country: string;
+    language: string | undefined;
+    locale: string | undefined;
+} | null;
+/**
+ * `Tether.setCountry('DE')`: loads the markets part on first use.
+ *
+ * @returns The cart once everything is in the new market.
+ */
+export declare function setCountry(code: string, options?: SetCountryOptions): Promise<ShopifyCart | null>;