@occluze/tether 0.6.8 → 0.7.0

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

@@ -0,0 +1,12 @@
+/** What the entry module does for a page. */
+interface PageHooks {
+    /** Settles once `init()` has applied the visitor's market. */
+    ready: () => Promise<unknown>;
+    mount: (root: Document) => unknown;
+    unmount: () => void;
+}
+/** Records a mount of the whole document, so the `astro:page-load` of the same page sends no second round of requests. */
+export declare function rememberDocumentMount(): void;
+/** Binds the document-wide listeners, once per page load of the script. */
+export declare function bindNavigation(hooks: PageHooks): void;
+export {};

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

@@ -0,0 +1,19 @@
+type ProblemLevel = 'error' | 'warn';
+export interface Problem {
+    level: ProblemLevel;
+    message: string;
+    /** The element, described for people: `<div#id.class>`. */
+    element?: string;
+    /** The element itself, for the console. */
+    el?: Element;
+}
+/**
+ * @param value What the markup says.
+ * @param options What Tether reads.
+ * @param prefix Put before the suggestion, e.g. `tether-`.
+ * @returns ` Did you mean "…"?` for an option close enough to `value`, else `''`.
+ */
+export declare function didYouMean(value: string, options: Iterable<string>, prefix?: string): string;
+/** The markup problems in `root`, in page order per check. */
+export declare function checkMarkup(root?: ParentNode): Problem[];
+export {};

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

@@ -0,0 +1,60 @@
+import { apiVersionStatus } from './api-version.js';
+import { checkMarkup, didYouMean } from './diagnose-markup.js';
+import type { ApiVersionStatus } from './api-version.js';
+import type { DetectedMarket } from './markets.js';
+import type { Problem } from './diagnose-markup.js';
+export { apiVersionStatus, checkMarkup, didYouMean };
+/** The market in use (a visitor's choice included), and what detection would pick. */
+interface MarketReport {
+    country: string | null;
+    language: string | null;
+    locale: string | null;
+    /** `null` without `markets.detect`. */
+    detected: DetectedMarket | null;
+}
+interface ShopReport {
+    name: string;
+    url: string;
+    currency: string;
+}
+type ProductReport = {
+    key: string;
+    handle: string;
+    title: string;
+    plans: number;
+    requiresSellingPlan: boolean;
+} | {
+    key: string;
+    error: string | undefined;
+};
+interface SellingPlanReport {
+    product: string;
+    group: string;
+    plan: string;
+    id: string;
+}
+export interface DiagnoseReport {
+    /** Tether's version, `''` when the caller didn't say. */
+    version: string;
+    /** The config, with the token masked. */
+    config: Record<string, unknown>;
+    apiVersion: ApiVersionStatus;
+    market: MarketReport;
+    reachable: boolean;
+    shop: ShopReport | null;
+    latencyMs: number | null;
+    products: ProductReport[];
+    sellingPlans: SellingPlanReport[];
+    problems: Problem[];
+}
+export interface DiagnoseOptions {
+    root?: ParentNode;
+    /** Return the report without logging it. */
+    silent?: boolean;
+    /** Tether's version, for the report. */
+    version?: string;
+    /** The date the API version's support is measured against. */
+    now?: Date;
+}
+/** What's wrong on the page: config, token, API version, products, plans, markup. */
+export declare function diagnose({ root, silent, version, now, }?: DiagnoseOptions): Promise<DiagnoseReport>;

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

@@ -0,0 +1,75 @@
+import type { Money } from './shopify-values.js';
+export { attr, sel, get, has, qsa, scoped, emit, ownEvent, isOwnEvent, ANALYTICS_EVENTS } from './markup.js';
+export { imageUrl, cdnUrl, sameImage, setImage } from './images.js';
+export { hasTemplate, repeat, repeatKeyed } from './repeaters.js';
+/**
+ * The product page of a product (`productPath`).
+ *
+ * @returns `null` without the handle or id the path needs.
+ */
+export declare function productUrl(handle: string | null | undefined, id?: string | null): string | null;
+/**
+ * `30` → `30%` (en, nl) or `30 %` (de, fr), in the configured locale.
+ *
+ * @returns `''` for no or a zero percentage.
+ */
+export declare function formatPercent(percentage: number | null | undefined, locale?: string | undefined): string;
+/** Money in the configured locale, through the site's `formatMoney` when it has one. */
+export declare function formatMoney(money: Money | null | undefined): string;
+/** @returns The date in the configured locale, `''` without one. */
+export declare function formatDate(iso: string | null | undefined): string;
+/**
+ * Writes HTML from the Shopify admin (product and collection descriptions) into `el`, with script removed
+ * (`store-html.ts`). Everything else from Shopify is written as text (`setText`).
+ */
+export declare function setStoreHtml(el: Element, html: string | null | undefined): void;
+/**
+ * Sets the text of `el`, or its value when it is a form field.
+ *
+ * @param value `null` and `undefined` clear it.
+ */
+export declare function setText(el: Element, value: string | number | boolean | null | undefined): void;
+/** `setText` that hands a change after the first render to `onValueChange`, for scramble and roll effects. */
+export declare function setTextTracked(el: HTMLElement, value: string | number | boolean | null | undefined): void;
+/** Shows or hides `el`, restoring its own display value when shown again. */
+export declare function show(el: HTMLElement, visible: boolean): void;
+/** Marks an option button or input as chosen: `is-selected`, `aria-pressed`, and its own or inner radio/checkbox. */
+export declare function setSelected(el: Element, selected: boolean): void;
+/**
+ * A global the page's own scripts set on `window`: `TETHER_CONFIG`, the site's config, `TETHER_INTEGRATION`, set by a
+ * framework integration (Astro) that starts Tether itself, and GSAP's `ScrollTrigger`. Another script wrote it, so it
+ * is read as unknown and checked where it is used.
+ */
+export declare const pageGlobal: (name: "TETHER_CONFIG" | "TETHER_INTEGRATION" | "ScrollTrigger") => unknown;
+/**
+ * Async renders change the page height after the site's page-transition hooks ran. After a burst of them this calls
+ * `onLayoutChange` (else refreshes ScrollTrigger) and emits `tether:layout-changed`, also when either of those throws.
+ */
+export declare function notifyLayoutChanged(reason: string): void;
+/** Notifies a layout change (`<reason>:images`) once every image in `root` that is still loading has loaded or failed. */
+export declare function watchImages(root: ParentNode, reason: string): void;
+/**
+ * Runs `task` with `aria-busy` on `el`; does nothing while `el` is already busy.
+ *
+ * @returns The task's result, `undefined` when it didn't run.
+ */
+export declare function busy<T>(el: Element, task: () => T | Promise<T>): Promise<T | undefined>;
+/** @returns The attribute's JSON, `null` when it is missing or not JSON (with a warning). */
+export declare function parseJSONAttr(el: Element | null | undefined, name: string): unknown;
+export type AttributeValue = string | number | boolean | null | undefined;
+/**
+ * `tether-line-attributes`, JSON the site writes: `{ a: 1 }` or `[{ key, value }]`. An array entry that isn't an
+ * object is skipped.
+ */
+export declare function attributesFromJson(json: unknown): {
+    key: string;
+    value: string;
+}[];
+/** `{ a: 1 }` or `[{ key, value }]` → `[{ key, value }]` as Shopify wants cart and line attributes. */
+export declare function toAttributes(attributes: Record<string, AttributeValue> | {
+    key: string | number;
+    value?: AttributeValue;
+}[] | null | undefined): {
+    key: string;
+    value: string;
+}[];

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

@@ -0,0 +1,21 @@
+import type { ShopifyCart } from './cart/store.js';
+/**
+ * `[tether-group]` with `[tether-group-add]`: adds every product scope inside the group in one request, for bundles,
+ * build-a-box and "complete the set". The lines get the attribute `_group` and the group's `tether-line-attributes`.
+ *
+ * @returns The cart, `null` with nothing to add or after a reported failure.
+ */
+export declare function addGroup(button: Element): Promise<ShopifyCart | null>;
+/** Another tab changed the cart (it is loaded again here) or the visitor's market (this tab follows it). */
+export declare function onStorage(event: StorageEvent): void;
+/**
+ * `?variant=` (and `selling_plan=`) follow the visitor's choice.
+ *
+ * @param root The product scope's root.
+ */
+export declare function writeVariantUrl(root: Element, { variant, sellingPlanId }: {
+    variant: {
+        id: string;
+    };
+    sellingPlanId: string | null | undefined;
+}): void;

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

@@ -0,0 +1,158 @@
+import type { TetherConfig } from './config.js';
+import type { Money } from './shopify-values.js';
+import type { StoreAccess } from './client.js';
+export interface Image {
+    url: string;
+    altText: string | null;
+    width: number | null;
+    height: number | null;
+}
+/** An option value's swatch: a colour, an image, or both, as the merchant set them in the admin. */
+interface Swatch {
+    color: string | null;
+    image: {
+        previewImage: Image | null;
+    } | null;
+}
+export type SellingPlanAdjustmentValue = {
+    __typename: 'SellingPlanPercentagePriceAdjustment';
+    adjustmentPercentage: number;
+} | {
+    __typename: 'SellingPlanFixedAmountPriceAdjustment';
+    adjustmentAmount: Money;
+} | {
+    __typename: 'SellingPlanFixedPriceAdjustment';
+    price: Money;
+};
+export interface SellingPlan {
+    id: string;
+    name: string;
+    description: string | null;
+    recurringDeliveries: boolean;
+    options: {
+        name: string;
+        value: string;
+    }[];
+    priceAdjustments: {
+        orderCount: number | null;
+        adjustmentValue: SellingPlanAdjustmentValue;
+    }[];
+}
+export interface SellingPlanGroup {
+    name: string;
+    appName: string | null;
+    options: {
+        name: string;
+        values: string[];
+    }[];
+    sellingPlans: {
+        nodes: SellingPlan[];
+    };
+}
+/** A variant's price on one plan. */
+export interface SellingPlanAllocation {
+    sellingPlan: {
+        id: string;
+    };
+    /** What the customer pays at checkout (more for a prepaid plan). */
+    checkoutChargeAmount: Money;
+    remainingBalanceChargeAmount: Money;
+    priceAdjustments: {
+        price: Money;
+        compareAtPrice: Money;
+        perDeliveryPrice: Money;
+        unitPrice: Money | null;
+    }[];
+}
+export interface ProductVariant {
+    id: string;
+    title: string;
+    availableForSale: boolean;
+    currentlyNotInStock: boolean;
+    /** Absent when the store's token can't read inventory. */
+    quantityAvailable?: number | null;
+    sku: string | null;
+    barcode: string | null;
+    selectedOptions: {
+        name: string;
+        value: string;
+    }[];
+    image: Image | null;
+    price: Money;
+    compareAtPrice: Money | null;
+    unitPrice: Money | null;
+    sellingPlanAllocations: {
+        nodes: SellingPlanAllocation[];
+    };
+}
+export interface Metafield {
+    namespace: string;
+    key: string;
+    type: string;
+    value: string;
+    /** A file reference's image. */
+    reference: {
+        image?: Image;
+    } | null;
+}
+/** The fields of `fragment TetherProduct`. */
+export interface Product {
+    id: string;
+    handle: string;
+    title: string;
+    description: string;
+    descriptionHtml: string;
+    productType: string;
+    vendor: string;
+    tags: string[];
+    availableForSale: boolean;
+    publishedAt: string | null;
+    onlineStoreUrl: string | null;
+    requiresSellingPlan: boolean;
+    seo: {
+        title: string | null;
+        description: string | null;
+    };
+    featuredImage: Image | null;
+    images: {
+        nodes: Image[];
+    };
+    options: {
+        name: string;
+        optionValues: {
+            name: string;
+            swatch: Swatch | null;
+        }[];
+    }[];
+    priceRange: {
+        minVariantPrice: Money;
+        maxVariantPrice: Money;
+    };
+    compareAtPriceRange: {
+        minVariantPrice: Money;
+        maxVariantPrice: Money;
+    };
+    /** Present when metafields are configured; `null` for one that isn't set. */
+    metafields?: (Metafield | null)[];
+    sellingPlanGroups: {
+        nodes: SellingPlanGroup[];
+    };
+    variants: {
+        nodes: ProductVariant[];
+    };
+}
+export type ProductFragmentConfig = Pick<TetherConfig, 'imagesFirst' | 'variantsFirst' | 'sellingPlanGroupsFirst' | 'sellingPlansFirst' | 'metafields'>;
+/**
+ * @param o The list sizes and metafields.
+ * @param access What the token may read.
+ * @returns `fragment TetherProduct on Product`.
+ */
+export declare function productFragment(o?: ProductFragmentConfig, access?: StoreAccess): string;
+/**
+ * @param access What the token may read.
+ * @returns `fragment TetherCart on Cart`.
+ */
+export declare function cartFragment(access?: StoreAccess): string;
+/** The collection fields Tether renders, for inside a `collection { }` selection. */
+export declare function collectionFields(): string;
+export {};

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

@@ -0,0 +1,15 @@
+/**
+ * What Tether reads from and sets on `window`, for sites that use the `<script>` build or `window.Tether`. Only the
+ * published declarations carry it (scripts/build.ts adds it to the generated `index.d.ts`): the source reads these
+ * names as unknown and validates them, so they stay out of its own program.
+ */
+import type { Tether, TetherConfig } from './index.js';
+
+declare global {
+  interface Window {
+    Tether: Tether;
+    TETHER_CONFIG?: TetherConfig;
+    TETHER_COUNTRY?: string;
+    TETHER_LANGUAGE?: string;
+  }
+}

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

@@ -0,0 +1,20 @@
+/** Shopify CDN parameters. */
+export interface ImageSize {
+    width?: string | number | null;
+    height?: string | number | null;
+    /** `center`, `top`, `bottom`, `left` or `right`; only applies with a width or height. */
+    crop?: string | null;
+}
+/**
+ * Shopify CDN image at a size: `imageUrl(url, { width: 800 })`. Use the same width as the element's max-width
+ * attribute, so the browser script keeps the image instead of loading it again.
+ *
+ * @returns The sized URL; `url` itself when it is empty or not absolute.
+ */
+export declare function imageUrl<Url extends string | null | undefined>(url: Url, { width, height, crop }?: ImageSize): Url;
+/** @param el The element whose max-width / max-height / crop attributes size the image. */
+export declare function cdnUrl<Url extends string | null | undefined>(url: Url, el: Element | null | undefined): Url;
+/** @returns True for the same image at any size parameters: the server-rendered one is kept. */
+export declare function sameImage(a: string | null | undefined, b: string | null | undefined): boolean;
+/** Shows `url` in `el`: as the `src` of an `<img>` (lazy unless it says otherwise), else as its background image. */
+export declare function setImage(el: HTMLElement, url: string | null | undefined, alt?: string | null): void;

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;