@occluze/tether 0.7.0 → 0.7.2

package/src/analytics.ts

@@ -1,315 +0,0 @@
-/**
- * Analytics, as an optional part (loaded when config.analytics is set).
- *
- *   analytics: {
- *     dataLayer: true,        // GA4 / Google Tag Manager ecommerce events (window.dataLayer)
- *     shopify: true,          // Shopify's own analytics (experimental, see docs/analytics.md)
- *     onEvent(name, data) {}, // any other tool: Meta, TikTok, Plausible
- *   }
- *
- * Events: view_item (the page's product), view_item_list (lists), add_to_cart / remove_from_cart (from the cart's
- * changes, so quick +/- and JS calls count too), view_cart (cart opened), begin_checkout, search (search as you type).
- * Purchases happen on Shopify's checkout: use Shopify's Google & YouTube app or a checkout pixel for those.
- * Shopify's analytics are set up in analytics-shopify.ts.
- */
-import { cfg, reportError } from './config.ts';
-import { ANALYTICS_EVENTS, isOwnEvent, sel } from './dom.ts';
-import { Cart } from './cart.ts';
-import { scopes } from './product.ts';
-import { startShopifyAnalytics } from './analytics-shopify.ts';
-import type { Money } from './shopify-values.ts';
-import type { Product, ProductVariant } from './fragments.ts';
-import type { AnalyticsBus, EventPayload } from './analytics-shopify.ts';
-import type { ProductScope } from './product.ts';
-import type { AnalyticsEventName, TetherEvents } from './markup.ts';
-
-/** The fields of the cart's product (`fragment TetherCart`) this module reads. */
-interface LineProduct {
-  id: string;
-  title: string;
-  handle: string;
-  vendor: string;
-}
-
-interface LineVariant {
-  id: string;
-  title: string;
-  sku: string | null;
-  price: Money;
-  product: LineProduct;
-}
-
-interface CartLine {
-  id: string;
-  quantity: number;
-  merchandise: LineVariant;
-}
-
-/** The fields of the cart (`fragment TetherCart`) this module reads. */
-interface AnalyticsCart {
-  lines: { nodes: CartLine[] };
-  cost: { totalAmount: Money };
-  discountCodes: { code: string; applicable: boolean }[];
-}
-
-/** What a GA4 item is built from: a product, or a cart line's product. */
-interface ItemProduct {
-  id: string;
-  title: string;
-  vendor?: string;
-  productType?: string;
-  priceRange?: { minVariantPrice: Money };
-}
-
-type ItemVariant = Pick<ProductVariant, 'id' | 'title' | 'sku' | 'price'>;
-
-/** A GA4 ecommerce item. */
-interface AnalyticsItem {
-  item_id: string;
-  item_name: string;
-  item_variant: string | undefined;
-  item_brand: string | undefined;
-  item_category: string | undefined;
-  price: number;
-  quantity: number;
-  index?: number;
-}
-
-/** Shopify's title for the one variant of a product without options. */
-const DEFAULT_VARIANT_TITLE = 'Default Title';
-const CENTS_PER_UNIT = 100;
-/** GA4 drops an event with more items than this. */
-const MAX_LIST_ITEMS = 200;
-
-const amountOf = (money: Money | null | undefined): number => (money ? parseFloat(money.amount) : 0);
-
-/** The numeric part of a gid. */
-const numericId = (gid: string | null | undefined): string => (gid ?? '').split('/').pop() ?? '';
-
-/** @param index The position in a list. */
-function itemFromVariant(
-  product: ItemProduct,
-  variant: ItemVariant | null | undefined,
-  quantity = 1,
-  index?: number,
-): AnalyticsItem {
-  const item: AnalyticsItem = {
-    item_id: variant?.sku || numericId(variant?.id) || numericId(product.id),
-    item_name: product.title,
-    item_variant: variant?.title === DEFAULT_VARIANT_TITLE ? undefined : variant?.title,
-    item_brand: product.vendor || undefined,
-    item_category: product.productType || undefined,
-    price: amountOf(variant?.price ?? product.priceRange?.minVariantPrice),
-    quantity,
-  };
-  if (index != null) item.index = index;
-  return item;
-}
-
-const itemFromLine = (line: CartLine, quantity = line.quantity) =>
-  itemFromVariant(line.merchandise.product, line.merchandise, quantity);
-
-/** The items' total, rounded to cents. */
-function totalValue(items: AnalyticsItem[]): number {
-  const total = items.reduce((sum, item) => sum + item.price * (item.quantity || 1), 0);
-  return Math.round(total * CENTS_PER_UNIT) / CENTS_PER_UNIT;
-}
-
-const productPayload = (product: Product, variant: ItemVariant, quantity = 1) => ({
-  id: product.id,
-  title: product.title,
-  price: variant.price,
-  vendor: product.vendor || '',
-  variantId: variant.id,
-  variantTitle: variant.title,
-  quantity,
-  sku: variant.sku || undefined,
-  productType: product.productType || undefined,
-});
-
-const linePayload = (line: CartLine) => ({
-  id: line.id,
-  quantity: line.quantity,
-  merchandise: {
-    id: line.merchandise.id,
-    title: line.merchandise.title,
-    price: line.merchandise.price,
-    sku: line.merchandise.sku,
-    product: {
-      id: line.merchandise.product.id,
-      title: line.merchandise.product.title,
-      vendor: line.merchandise.product.vendor || '',
-      handle: line.merchandise.product.handle,
-    },
-  },
-});
-
-/** The GA4 / GTM data layer, created when the page has none. */
-function dataLayer(): unknown[] {
-  const { dataLayer: option } = cfg.analytics ?? {};
-  const name = typeof option === 'string' ? option : 'dataLayer';
-  const existing: unknown = Reflect.get(window, name);
-  if (Array.isArray(existing)) return existing;
-  const created: unknown[] = [];
-  Reflect.set(window, name, created);
-  return created;
-}
-
-function pushToDataLayer(event: string, ecommerce: Record<string, unknown> | undefined): void {
-  const layer = dataLayer();
-  if (!ecommerce) {
-    layer.push({ event });
-    return;
-  }
-  // Google asks for the previous ecommerce object to be cleared first.
-  layer.push({ ecommerce: null });
-  layer.push({ event, ecommerce });
-}
-
-let bus: AnalyticsBus | null = null;
-/** Variant id to line, to turn cart changes into add and remove events. */
-let lastLines: Map<string, CartLine> | null = null;
-let lastCart: AnalyticsCart | null = null;
-/** Product roots whose view_item was sent on this page. */
-let viewed = new WeakSet<Element>();
-
-/** @param name The GA4 event. */
-function send(name: string, data: Record<string, unknown>, shopifyEvent?: string, shopifyPayload?: EventPayload): void {
-  if (cfg.analytics?.dataLayer) pushToDataLayer(name, data);
-  if (bus && shopifyEvent) bus.publish(shopifyEvent, shopifyPayload);
-  try {
-    cfg.analytics?.onEvent?.(name, data);
-  } catch (error) {
-    reportError(error, 'analytics onEvent');
-  }
-}
-
-/** The scope of the page's own product: a product root outside every list. */
-function mainProduct(): ProductScope | null {
-  const el = document.querySelector(sel('product'));
-  if (!el || el.closest(`${sel('collection')},${sel('products')},${sel('recommendations')}`)) return null;
-  return scopes.get(el) ?? null;
-}
-
-function onProductReady({ product, scope }: TetherEvents['product-ready']): void {
-  if (viewed.has(scope.root) || mainProduct() !== scope) return;
-  viewed.add(scope.root);
-  const variant = scope.variant ?? product.variants.nodes[0];
-  const items = [itemFromVariant(product, variant)];
-  const products = variant ? [productPayload(product, variant)] : [];
-  send('view_item', { currency: variant?.price.currencyCode, value: totalValue(items), items }, 'product_viewed', {
-    products,
-  });
-}
-
-function onListReady({ products, collection }: TetherEvents['list-ready']): void {
-  const items = products
-    .slice(0, MAX_LIST_ITEMS)
-    .map((product, index) => itemFromVariant(product, product.variants.nodes[0], 1, index));
-  const list = { item_list_id: collection?.handle || 'products', item_list_name: collection?.title || 'Products' };
-  if (!collection) {
-    send('view_item_list', { ...list, items });
-    return;
-  }
-  send('view_item_list', { ...list, items }, 'collection_viewed', {
-    collection: { id: collection.id, handle: collection.handle },
-  });
-}
-
-function sendCartChanges(cart: AnalyticsCart | null, now: Map<string, CartLine>, before: Map<string, CartLine>): void {
-  const currency = cart?.cost.totalAmount.currencyCode;
-  now.forEach((line, variantId) => {
-    const previous = before.get(variantId);
-    const added = line.quantity - (previous?.quantity ?? 0);
-    if (added <= 0) return;
-    const items = [itemFromLine(line, added)];
-    send('add_to_cart', { currency, value: totalValue(items), items }, 'product_added_to_cart', {
-      cart,
-      prevCart: lastCart,
-      currentLine: linePayload(line),
-      prevLine: previous ? linePayload(previous) : undefined,
-    });
-  });
-  before.forEach((line, variantId) => {
-    const removed = line.quantity - (now.get(variantId)?.quantity ?? 0);
-    if (removed <= 0) return;
-    const items = [itemFromLine(line, removed)];
-    send('remove_from_cart', { currency, value: totalValue(items), items });
-  });
-}
-
-function onCartUpdated({ cart, reason }: TetherEvents['cart-updated']): void {
-  const now = new Map((cart?.lines.nodes ?? []).map((line) => [line.merchandise.id, line]));
-  // Loading the saved cart and showing a pending change aren't changes the visitor made.
-  if (lastLines && reason !== 'load' && reason !== 'pending') sendCartChanges(cart, now, lastLines);
-  lastLines = now;
-  lastCart = cart;
-}
-
-function onCartOpened(): void {
-  const items = Cart.lines.map((line) => itemFromLine(line));
-  send('view_cart', { currency: Cart.state?.cost.totalAmount.currencyCode, value: totalValue(items), items });
-}
-
-function onCheckout({ cart }: TetherEvents['checkout']): void {
-  if (!cart) return;
-  const items = cart.lines.nodes.map((line) => itemFromLine(line));
-  const coupons = cart.discountCodes.filter((discount) => discount.applicable).map((discount) => discount.code);
-  send('begin_checkout', {
-    currency: cart.cost.totalAmount.currencyCode,
-    value: totalValue(items),
-    coupon: coupons.join(',') || undefined,
-    items,
-  });
-}
-
-/** What each event `ANALYTICS_EVENTS` names sends: one entry per name, so the list and this table can't diverge. */
-const REPORTERS: { [Name in AnalyticsEventName]: (detail: TetherEvents[Name]) => void } = {
-  'product-ready': onProductReady,
-  'list-ready': onListReady,
-  'cart-updated': onCartUpdated,
-  'cart-toggled': ({ open }) => {
-    if (open) onCartOpened();
-  },
-  checkout: onCheckout,
-  search: ({ term }) => {
-    if (term) send('search', { search_term: term }, 'search_viewed', { searchTerm: term });
-  },
-};
-
-/** @param event The event Tether created as `name`. */
-function report<Name extends AnalyticsEventName>(event: CustomEvent<TetherEvents[Name]>, name: Name): void {
-  REPORTERS[name](event.detail);
-}
-
-/**
- * Turns one buffered event into analytics events: a Tether event from `ANALYTICS_EVENTS`, or Astro's `astro:page-load`
- * for a client-side navigation, which starts a new page view. Only events Tether created count (`isOwnEvent`): a
- * look-alike another script dispatches, whatever its detail, sends nothing.
- */
-function handle(event: Event): void {
-  if (event.type === 'astro:page-load') {
-    viewed = new WeakSet();
-    bus?.publish('page_viewed', {});
-    return;
-  }
-  ANALYTICS_EVENTS.forEach((name) => {
-    if (isOwnEvent(event, name)) report(event, name);
-  });
-}
-
-/** Called by the core with the events it buffered while this part loaded; the queue then handles events as they come. */
-export async function startAnalytics(queue: Event[]): Promise<void> {
-  if (cfg.analytics?.shopify) {
-    bus = await startShopifyAnalytics(() => mainProduct() != null).catch((error: unknown) => {
-      reportError(error, 'shopify analytics');
-      return null;
-    });
-  }
-  bus?.publish('page_viewed', {});
-  queue.splice(0).forEach(handle);
-  queue.push = (...events) => {
-    events.forEach(handle);
-    return queue.length;
-  };
-}

package/src/api-version.ts

@@ -1,79 +0,0 @@
-/**
- * Shopify API versions are quarterly (YYYY-01, -04, -07, -10) and supported for 12 months. Tether pins a dated version
- * and never targets `unstable` (it changes without notice). Used by the config, the diagnose part and the release
- * scripts.
- */
-
-import type { ApiVersion } from '../server/src/shared/api-versions.ts';
-
-const QUARTERLY_VERSION = /^(\d{4})-(01|04|07|10)$/;
-const MONTHS_PER_QUARTER = 3;
-const QUARTERS_PER_YEAR = 4;
-const MONTHS_SUPPORTED = 12;
-/** Months left at which the status starts asking for an upgrade. */
-const UPGRADE_WARNING_MONTHS = 3;
-const AVERAGE_MONTH_MS = 30.44 * 24 * 3600 * 1000;
-
-export interface ApiVersionStatus {
-  version: string;
-  /** Released and still supported. */
-  ok: boolean;
-  /** What to do about it, for people. */
-  note: string;
-  /** Months of support left, rounded; negative once support ended. */
-  monthsLeft?: number;
-  /** The version after this one. */
-  next?: string;
-}
-
-function parseVersion(version: unknown): { year: number; month: number } | null {
-  const match = QUARTERLY_VERSION.exec(typeof version === 'string' ? version : '');
-  if (!match) return null;
-  return { year: Number(match[1]), month: Number(match[2]) };
-}
-
-/** @returns True for a dated version such as `2026-07`. */
-export const isQuarterlyVersion = (version: unknown): version is ApiVersion => parseVersion(version) !== null;
-
-/** @param month 1 to 12. */
-const formatVersion = (year: number, month: number) => `${year}-${String(month).padStart(2, '0')}`;
-
-/**
- * `'2026-07'` → `'2026-10'`, `'2026-10'` → `'2027-01'`.
- *
- * @param steps Quarters ahead.
- * @throws {Error} When `version` isn't a quarterly version.
- */
-export function nextApiVersion(version: string, steps = 1): string {
-  const parsed = parseVersion(version);
-  if (!parsed) throw new Error(`not a quarterly Shopify API version: ${version}`);
-  const quarter = parsed.year * QUARTERS_PER_YEAR + (parsed.month - 1) / MONTHS_PER_QUARTER + steps;
-  return formatVersion(Math.floor(quarter / QUARTERS_PER_YEAR), (quarter % QUARTERS_PER_YEAR) * MONTHS_PER_QUARTER + 1);
-}
-
-/** The support window of `version`, relative to `now`. */
-export function apiVersionStatus(version: string, now = new Date()): ApiVersionStatus {
-  if (version === 'unstable') {
-    return { version, ok: false, note: '"unstable" changes without notice: pin a dated version such as 2026-07' };
-  }
-  const parsed = parseVersion(version);
-  if (!parsed) return { version, ok: false, note: 'not a quarterly version (YYYY-01, -04, -07 or -10)' };
-  const released = new Date(Date.UTC(parsed.year, parsed.month - 1, 1));
-  const supportedUntil = new Date(Date.UTC(parsed.year, parsed.month - 1 + MONTHS_SUPPORTED, 1));
-  const monthsLeft = (supportedUntil.getTime() - now.getTime()) / AVERAGE_MONTH_MS;
-  const isReleased = released <= now;
-  let note = `supported until about ${supportedUntil.toISOString().slice(0, 7)}`;
-  if (!isReleased) note = 'not released yet (release candidate at best)';
-  else if (monthsLeft <= 0) {
-    note = 'no longer supported: Shopify falls back to the oldest supported version. Upgrade (see README)';
-  } else if (monthsLeft < UPGRADE_WARNING_MONTHS) {
-    note = `${note}: plan the upgrade to ${nextApiVersion(version)} or later (see README)`;
-  }
-  return {
-    version,
-    ok: isReleased && monthsLeft > 0,
-    monthsLeft: Math.round(monthsLeft),
-    next: nextApiVersion(version),
-    note,
-  };
-}

package/src/astro.ts

@@ -1,272 +0,0 @@
-/**
- * Astro integration: Tether on every page, configured from .env.
- *
- *   // astro.config.mjs
- *   import { defineConfig } from 'astro/config';
- *   import tether from '@occluze/tether/astro';
- *   export default defineConfig({ integrations: [tether({ country: 'NL', locale: 'nl-NL' })] });
- *
- *   // .env
- *   PUBLIC_SHOPIFY_DOMAIN=your-store.myshopify.com
- *   PUBLIC_SHOPIFY_STOREFRONT_TOKEN=your-public-storefront-token
- *
- * Options are Tether's config (domain and token override .env), and may be the object createStorefront() is given too:
- * its own options (siteUrl, pageSize) are left out of the page. Functions (onError, formatMoney, hooks) can't be
- * passed here: set them in window.TETHER_CONFIG in your layout, it is merged in. View Transitions (<ClientRouter />)
- * work without extra code. In dev, changes to src/shop.config.js restart the dev server (other files:
- * tether({ ..., watch: ['my/config.js'] })). Runs in Node, inside Astro's config step.
- */
-import { DEFAULTS } from './config.ts';
-import type { TetherOptions } from './config.ts';
-import type { StorefrontOptions } from './server.ts';
-import { isSecretShopifyToken, STORE_ENV_NAMES } from './shopify-values.ts';
-import { messageOf } from '../server/src/shared/error-message.ts';
-
-// Astro isn't a dependency, so the parts of its integration API this file uses are described here.
-interface AstroLogger {
-  warn: (message: string) => void;
-}
-type EnvStringField = (options: { context: 'client'; access: 'public'; optional: boolean }) => unknown;
-/** The argument of Astro's `astro:config:setup` hook. */
-interface AstroConfigSetup {
-  injectScript: (stage: 'head-inline' | 'page', content: string) => void;
-  /** `dev`, `build`, `preview` or `sync`. */
-  command: string;
-  config: { root?: URL };
-  logger: AstroLogger;
-  addWatchFile?: (path: string) => void;
-  /** Takes a partial Astro config. A method, so that Astro's own `DeepPartial<AstroConfig>` parameter fits. */
-  updateConfig?(config: { env?: { schema?: Record<string, unknown> } }): unknown;
-}
-
-/** The config options a page can be handed as JSON: all but the functions. */
-type SerializableOptions = {
-  [
-    Key in keyof TetherOptions as Exclude<TetherOptions[Key], null | undefined> extends (...args: never[]) => unknown
-      ? never
-      : Key
-  ]?: TetherOptions[Key];
-};
-
-/** `createStorefront()`'s own options that a config shared with it may hold, which the page leaves out. */
-type ServerOnlyOptions = Pick<StorefrontOptions, 'siteUrl' | 'pageSize'>;
-
-/** Tether's serializable config and the storefront's own options, plus the integration's own options. */
-interface TetherAstroOptions extends SerializableOptions, ServerOnlyOptions {
-  /** Add the Tether script to every page (default true). */
-  inject?: boolean;
-  /** Files that restart the dev server when they change. */
-  watch?: string[] | null;
-}
-interface PageConfig {
-  domain?: unknown;
-  token?: unknown;
-  [option: string]: unknown;
-}
-type Env = Record<string, string | undefined>;
-
-export type { TetherAstroOptions, AstroConfigSetup };
-
-const DEFAULT_WATCH = ['src/shop.config.js', 'src/shop.config.mjs', 'src/shop.config.ts'];
-/** The keys of `ServerOnlyOptions`: the browser has no use for them. */
-const SERVER_OPTIONS = new Set(['siteUrl', 'pageSize']);
-/**
- * Astro is an optional peer dependency. A variable specifier keeps both tsc and the bundler from resolving it.
- */
-const ASTRO_CONFIG_MODULE = 'astro/config';
-const ENV_LINE = /^\s*(?:export\s+)?([\w.-]+)\s*=\s*(.*?)\s*$/;
-/** A quoted value; a `#` comment may follow the closing quote. */
-const QUOTED_VALUE = /^(["'])(.*?)\1/;
-
-/** @returns The mode Astro runs in: `--mode`, else development for dev and production for everything else. */
-function modeOf(command: string, argv: readonly string[] = process.argv): string {
-  const defaultMode = command === 'dev' ? 'development' : 'production';
-  const index = argv.findIndex((arg) => arg === '--mode' || arg.startsWith('--mode='));
-  if (index < 0) return defaultMode;
-  const flag = argv[index] ?? '';
-  const mode = flag.includes('=') ? flag.split('=')[1] : argv[index + 1];
-  return mode ?? defaultMode;
-}
-
-/** @returns True for Node's "no such file" error. */
-const isMissingFile = (error: unknown): boolean => error instanceof Error && 'code' in error && error.code === 'ENOENT';
-
-/** @returns The file's text, `null` when it doesn't exist: every .env file is optional. */
-async function readOptionalFile(path: string): Promise<string | null> {
-  const { readFile } = await import('node:fs/promises');
-  try {
-    return await readFile(path, 'utf8');
-  } catch (error) {
-    if (isMissingFile(error)) return null;
-    throw error;
-  }
-}
-
-/**
- * @param text A .env file.
- * @param into Receives each variable; a later line wins.
- */
-function parseEnvFile(text: string, into: Env) {
-  for (const line of text.split(/\r?\n/)) {
-    const match = ENV_LINE.exec(line);
-    if (!match || line.trim().startsWith('#')) continue;
-    const [, name = '', raw = ''] = match;
-    const quoted = QUOTED_VALUE.exec(raw);
-    into[name] = quoted ? (quoted[2] ?? '') : raw.replace(/\s+#.*$/, '');
-  }
-}
-
-/**
- * @param root The project folder.
- * @returns The .env files the way Vite reads them (later files win), with `process.env` on top.
- */
-async function readEnv(command: string, root: string): Promise<Env> {
-  const path = await import('node:path');
-  const mode = modeOf(command);
-  const env: Env = {};
-  for (const name of ['.env', '.env.local', `.env.${mode}`, `.env.${mode}.local`]) {
-    const text = await readOptionalFile(path.join(root, name));
-    if (text !== null) parseEnvFile(text, env);
-  }
-  return { ...env, ...process.env };
-}
-
-/**
- * Fills the store's domain and token from .env when the options don't set them, and refuses a secret token: whatever
- * is read here is written into every page.
- *
- * @param config Changed in place.
- * @throws {Error} When the token is a secret Shopify token.
- */
-function applyStoreEnv(config: PageConfig, env: Env, logger: AstroLogger) {
-  for (const key of ['domain', 'token'] as const) {
-    if (config[key]) continue;
-    const name = STORE_ENV_NAMES[key].find((candidate) => env[candidate]);
-    if (!name) continue;
-    config[key] = env[name];
-    // Whatever is read here is written into every page, so a name without PUBLIC_ is a mistake waiting to happen.
-    if (!name.startsWith('PUBLIC_')) {
-      logger.warn(`${name} is written into every page as Tether's ${key}. Name it PUBLIC_${name} to say so.`);
-    }
-  }
-  if (typeof config.token === 'string' && isSecretShopifyToken(config.token)) {
-    throw new Error(
-      'The Shopify token for Tether is a secret token (shpat_/shpss_/…), which would be published in every page. Use the public Storefront API token from the Headless channel.',
-    );
-  }
-}
-
-/**
- * The options usually come from a file the Astro config imports (src/shop.config.js): the dev server restarts when it
- * changes, so the browser gets the new config too.
- */
-async function watchConfigFiles(root: string, files: readonly string[], addWatchFile: (path: string) => void) {
-  const { existsSync } = await import('node:fs');
-  const path = await import('node:path');
-  for (const file of files) {
-    const absolute = path.resolve(root, file);
-    if (existsSync(absolute)) addWatchFile(absolute);
-  }
-}
-
-/** @returns The module, `null` when the package isn't installed. */
-async function importIfInstalled(specifier: string): Promise<unknown> {
-  try {
-    const module: unknown = await import(specifier);
-    return module;
-  } catch (error) {
-    if (error instanceof Error && 'code' in error && error.code === 'ERR_MODULE_NOT_FOUND') return null;
-    throw error;
-  }
-}
-
-/**
- * @param envField `astro/config`'s `envField`, which Astro 4 doesn't have.
- * @returns True when it has the `string` field Astro 5 documents.
- */
-const hasStringField = (envField: unknown): envField is { string: EnvStringField } =>
-  typeof envField === 'object' && envField !== null && 'string' in envField && typeof envField.string === 'function';
-
-/**
- * Declares the store variables in `astro:env` (Astro 5+), so Astro checks them. Astro 4 has no `envField`.
- */
-async function declareEnvSchema(setup: AstroConfigSetup) {
-  if (!setup.updateConfig) return;
-  const astroConfig = await importIfInstalled(ASTRO_CONFIG_MODULE);
-  const envField =
-    typeof astroConfig === 'object' && astroConfig !== null && 'envField' in astroConfig ? astroConfig.envField : null;
-  if (!hasStringField(envField)) return;
-  const field = () => envField.string({ context: 'client', access: 'public', optional: true });
-  try {
-    setup.updateConfig({
-      env: { schema: { PUBLIC_SHOPIFY_DOMAIN: field(), PUBLIC_SHOPIFY_STOREFRONT_TOKEN: field() } },
-    });
-  } catch (error) {
-    // Astro versions with `envField` but without a stable `env` option refuse it; the variables still work unchecked.
-    setup.logger.warn(`.env variables not declared in astro:env: ${messageOf(error)}`);
-  }
-}
-
-/** @param config Changed in place: functions can't be written into a page. */
-function dropFunctions(config: PageConfig, logger: AstroLogger) {
-  const functions = Object.keys(config).filter((key) => typeof config[key] === 'function');
-  for (const key of functions) Reflect.deleteProperty(config, key);
-  if (functions.length) {
-    logger.warn(
-      `${functions.join(', ')}: functions can't be passed here. Set them in window.TETHER_CONFIG in your layout.`,
-    );
-  }
-}
-
-/** @param config Changed in place: only browser options are written into the page. */
-function keepBrowserOptions(config: PageConfig, logger: AstroLogger) {
-  for (const key of Object.keys(config)) {
-    if (key in DEFAULTS) continue;
-    Reflect.deleteProperty(config, key);
-    if (!SERVER_OPTIONS.has(key)) logger.warn(`${key} is not a Tether option: left out of the page.`);
-  }
-}
-
-function injectTether(injectScript: AstroConfigSetup['injectScript'], config: PageConfig) {
-  // Before any module runs: window.TETHER_CONFIG in the layout doesn't auto-start a second init.
-  injectScript('head-inline', 'window.TETHER_INTEGRATION="astro";');
-  injectScript(
-    'page',
-    [
-      "import Tether from '@occluze/tether';",
-      // As the base config (like window.TETHER_CONFIG), not as overrides: a visitor's saved market (country, money
-      // format) then wins over the defaults, as on a plain script-tag site.
-      `window.TETHER_CONFIG = { ...${JSON.stringify({ autoMount: false, ...config })}, ...(window.TETHER_CONFIG || {}) };`,
-      'Tether.init().then(() => Tether.mount(document));',
-    ].join('\n'),
-  );
-}
-
-export default function tether(options: TetherAstroOptions = {}): {
-  name: string;
-  hooks: { 'astro:config:setup': (setup: AstroConfigSetup) => Promise<void> };
-} {
-  const { inject = true, watch = DEFAULT_WATCH, ...pageOptions } = options;
-  return {
-    name: '@occluze/tether',
-    hooks: {
-      'astro:config:setup': async (setup) => {
-        const { injectScript, command, config: astroConfig, logger, addWatchFile } = setup;
-        const { fileURLToPath } = await import('node:url');
-        const root = astroConfig.root ? fileURLToPath(astroConfig.root) : process.cwd();
-        if (command === 'dev' && addWatchFile) await watchConfigFiles(root, watch ?? [], addWatchFile);
-        await declareEnvSchema(setup);
-        const config: PageConfig = { ...pageOptions };
-        applyStoreEnv(config, await readEnv(command, root), logger);
-        dropFunctions(config, logger);
-        keepBrowserOptions(config, logger);
-        if (!config.domain || !config.token) {
-          logger.warn(
-            'No Shopify store configured: set PUBLIC_SHOPIFY_DOMAIN and PUBLIC_SHOPIFY_STOREFRONT_TOKEN in .env (the public Storefront API token).',
-          );
-        }
-        if (inject) injectTether(injectScript, config);
-      },
-    },
-  };
-}

package/src/cart/cart-shape.ts

@@ -1,25 +0,0 @@
-/**
- * The structure of Tether's cart fragment, checked on a Storefront answer before it is used as a `ShopifyCart`. The
- * cart's render, its totals and the cart API walk its lines and prices without checking each step. Text fields are
- * written as text, so they need no check.
- */
-import { MONEY } from '../product-shape.ts';
-import type { Shape } from '../client.ts';
-
-const LINE = {
-  id: 'string',
-  quantity: 'number',
-  attributes: ['object'],
-  cost: { totalAmount: MONEY, subtotalAmount: MONEY, amountPerQuantity: MONEY },
-  merchandise: { id: 'string', selectedOptions: ['object'], product: 'object' },
-} as const satisfies Shape;
-
-export const CART = {
-  id: 'string',
-  checkoutUrl: 'string',
-  totalQuantity: 'number',
-  attributes: ['object'],
-  discountCodes: ['object'],
-  cost: { totalAmount: MONEY, subtotalAmount: MONEY },
-  lines: { nodes: [LINE] },
-} as const satisfies Shape;