@occluze/tether 0.6.7 → 0.7.0

package/src/loader.js

@@ -1,198 +0,0 @@
-/**
- * Data loading. Products are batched per tick into one request and cached for
- * the lifetime of the page (survives Barba/Swup page swaps).
- */
-import { cfg, log } from './config.js';
-import { gql, TetherError } from './client.js';
-import { productFragment, collectionFields } from './fragments.js';
-
-const productCache = new Map(); // key -> Promise<product>
-let pending = [];
-const resolvers = new Map();
-let scheduled = false;
-// Bumped by clearProductCache(): responses to requests sent before that (e.g. in the old
-// market after a country switch) still reach their callers but never refill the cache.
-let generation = 0;
-
-const isGid = (v) => typeof v === 'string' && v.startsWith('gid://');
-
-/** Accepts a handle, numeric id, gid or a full product URL. */
-export function normalizeProductKey(raw) {
-  const v = String(raw ?? '').trim();
-  if (!v) return null;
-  if (isGid(v)) return v;
-  if (/^\d+$/.test(v)) return `gid://shopify/Product/${v}`;
-  const m = v.match(/\/products\/([^/?#]+)/);
-  return m ? m[1] : v;
-}
-
-/** Put a product we already have (from a collection query) in the cache. */
-export function primeProduct(product) {
-  if (!product) return;
-  const p = Promise.resolve(product);
-  productCache.set(product.handle, p);
-  productCache.set(product.id, p);
-}
-
-export function getProduct(rawKey) {
-  const key = normalizeProductKey(rawKey);
-  if (!key) return Promise.reject(new TetherError('empty product key', { code: 'NOT_FOUND' }));
-  if (productCache.has(key)) return productCache.get(key);
-
-  const p = new Promise((resolve, reject) => {
-    resolvers.set(key, { resolve, reject });
-    pending.push(key);
-    if (!scheduled) {
-      scheduled = true;
-      setTimeout(flush, 0);
-    }
-  });
-  productCache.set(key, p);
-  return p;
-}
-
-async function flush() {
-  scheduled = false;
-  const gen = generation;
-  const keys = pending.splice(0);
-  if (!keys.length) return;
-
-  const ids = keys.filter(isGid);
-  const handles = keys.filter((k) => !isGid(k));
-  const defs = [];
-  const parts = [];
-  const vars = {};
-
-  if (ids.length) {
-    defs.push('$ids: [ID!]!');
-    vars.ids = ids;
-    parts.push('byId: nodes(ids: $ids) { ... on Product { ...TetherProduct } }');
-  }
-  handles.forEach((h, i) => {
-    defs.push(`$h${i}: String!`);
-    vars[`h${i}`] = h;
-    parts.push(`h${i}: product(handle: $h${i}) { ...TetherProduct }`);
-  });
-
-  const query = `query TetherProducts(${defs.join(',')}) { ${parts.join(' ')} } ${productFragment()}`;
-  log('fetch products', keys);
-
-  const settle = (k, fn) => {
-    const r = resolvers.get(k);
-    resolvers.delete(k);
-    if (r) fn(r);
-  };
-
-  try {
-    const data = await gql(query, vars);
-    const got = new Map();
-    (data.byId || []).forEach((p) => { if (p) got.set(p.id, p); });
-    handles.forEach((h, i) => { if (data[`h${i}`]) got.set(h, data[`h${i}`]); });
-
-    keys.forEach((k) => settle(k, (r) => {
-      if (got.has(k)) {
-        const p = got.get(k);
-        if (gen === generation) { primeProduct(p); freshAt.set(p.handle, Date.now()); freshAt.set(p.id, Date.now()); }
-        r.resolve(p);
-      } else {
-        // A miss is remembered for a few seconds (one page load asking twice makes one request),
-        // not longer: a product published in Shopify shows up on the next visit.
-        const miss = productCache.get(k);
-        if (gen === generation) setTimeout(() => { if (productCache.get(k) === miss) productCache.delete(k); }, 10000);
-        r.reject(new TetherError(`Product not found: ${k}`, { code: 'NOT_FOUND' }));
-      }
-    }));
-  } catch (err) {
-    keys.forEach((k) => settle(k, (r) => { if (gen === generation) productCache.delete(k); r.reject(err); }));
-  }
-}
-
-export function clearProductCache() { productCache.clear(); generation++; stale.clear(); freshAt.clear(); }
-
-// ---------------------------------------------------------------------------
-// Hydration: products rendered on the server (tether/server hydrate()) are used at once and
-// refreshed once in the background, so prices and stock are live without a loading state.
-// ---------------------------------------------------------------------------
-
-const stale = new Set(); // keys of products that came from the server and weren't refreshed yet
-const freshAt = new Map(); // key -> when it was last loaded live (this page session)
-const FRESH_MS = 60000;
-
-export function hydrateProducts(products) {
-  (products || []).forEach((p) => {
-    if (!p?.id || !p.handle) return;
-    // Loaded live in the last minute (an earlier page of a View Transition visit): that copy is newer.
-    if (Date.now() - (freshAt.get(p.handle) || 0) < FRESH_MS && productCache.has(p.handle)) return;
-    primeProduct(p);
-    stale.add(p.handle);
-    stale.add(p.id);
-  });
-}
-
-/** True once per server-provided product: the caller refreshes it. */
-export function takeStale(key) {
-  const k = normalizeProductKey(key);
-  if (!stale.has(k)) return false;
-  const p = productCache.get(k);
-  stale.delete(k);
-  // Both keys point to the same product: refresh it once.
-  p?.then?.((x) => { stale.delete(x.handle); stale.delete(x.id); });
-  return true;
-}
-
-/** Fetch these products again (bypassing the cache). */
-export function refreshProducts(keys) {
-  keys.forEach((k) => productCache.delete(normalizeProductKey(k)));
-  return keys.map((k) => getProduct(k));
-}
-
-/**
- * A page of products from a collection (by handle) or from a search query.
- * Returns { collection, products, pageInfo }.
- */
-export async function getProducts({
-  collection, query, first = cfg.collectionFirst, after = null, sortKey, reverse = false, filters,
-} = {}) {
-  const fragment = productFragment();
-
-  if (collection) {
-    const data = await gql(`query TetherCollection($handle: String!, $first: Int!, $after: String, $sortKey: ProductCollectionSortKeys, $reverse: Boolean, $filters: [ProductFilter!]) {
-  collection(handle: $handle) {
-    ${collectionFields()}
-    products(first: $first, after: $after, sortKey: $sortKey, reverse: $reverse, filters: $filters) {
-      nodes { ...TetherProduct }
-      pageInfo { hasNextPage endCursor }
-    }
-  }
-}
-${fragment}`, {
-      handle: collection, first, after, sortKey: sortKey || undefined, reverse, filters: filters || undefined,
-    });
-    if (!data.collection) throw new TetherError(`Collection not found: ${collection}`, { code: 'NOT_FOUND' });
-    const { products, ...rest } = data.collection;
-    products.nodes.forEach(primeProduct);
-    return { collection: rest, products: products.nodes, pageInfo: products.pageInfo };
-  }
-
-  const data = await gql(`query TetherSearch($first: Int!, $after: String, $query: String, $sortKey: ProductSortKeys, $reverse: Boolean) {
-  products(first: $first, after: $after, query: $query, sortKey: $sortKey, reverse: $reverse) {
-    nodes { ...TetherProduct }
-    pageInfo { hasNextPage endCursor }
-  }
-}
-${fragment}`, { first, after, query: query || undefined, sortKey: sortKey || undefined, reverse });
-  data.products.nodes.forEach(primeProduct);
-  return { collection: null, products: data.products.nodes, pageInfo: data.products.pageInfo };
-}
-
-export async function getRecommendations(product, intent = 'RELATED') {
-  const key = normalizeProductKey(typeof product === 'object' ? product?.id : product);
-  const byId = key?.startsWith('gid://');
-  const data = await gql(`query TetherRecs(${byId ? '$id: ID!' : '$handle: String!'}, $intent: ProductRecommendationIntent) {
-  productRecommendations(${byId ? 'productId: $id' : 'productHandle: $handle'}, intent: $intent) { ...TetherProduct }
-}
-${productFragment()}`, byId ? { id: key, intent } : { handle: key, intent });
-  const list = data.productRecommendations || [];
-  list.forEach(primeProduct);
-  return list;
-}

package/src/markets-ui.js

@@ -1,90 +0,0 @@
-/**
- * Optional part, loaded on first use: market detection, select[tether-country-select],
- * tether-country-bind and Tether.setCountry(). See markets.js for the detection rules.
- */
-import { cfg, reportError } from './config.js';
-import { TetherError } from './client.js';
-import { Cart } from './cart.js';
-import { listSelector } from './collection.js';
-import { clearProductCache } from './loader.js';
-import { attr, sel, get, emit } from './dom.js';
-import { within, pruneLive, liveLists, liveProducts, mountedProducts, mountProduct } from './mounting.js';
-import { rememberMarket, getLocalization, clearLocalization, toCountry, toLanguage } from './markets.js';
-
-export { detectMarket, getLocalization } from './markets.js';
-
-export /**
- * select[tether-country-select]: countries the store sells to (Shopify Markets).
- * tether-country-label="{name} ({currency})" sets the option text ({name}, {code}, {currency}, {symbol}).
- * tether-country-bind="name|code|currency|symbol" shows the current country anywhere.
- */
-function renderCountrySelects(root = document) {
-  const selects = within(root, `select${sel('country-select')}`);
-  const binds = within(root, sel('country-bind'));
-  if (!selects.length && !binds.length) return Promise.resolve();
-  return getLocalization().then((loc) => {
-    const current = (cfg.country || loc.country?.isoCode || '').toUpperCase();
-    const countries = [...(loc.availableCountries || [])].sort((a, b) => a.name.localeCompare(b.name, cfg.locale || undefined));
-    const info = countries.find((c) => c.isoCode === current) || loc.country;
-    const fill = (tpl, c) => tpl.replace(/\{name\}/g, c.name).replace(/\{code\}/g, c.isoCode)
-      .replace(/\{currency\}/g, c.currency?.isoCode || '').replace(/\{symbol\}/g, c.currency?.symbol || '');
-    selects.forEach((s) => {
-      const tpl = s.getAttribute(attr('country-label')) || '{name} ({currency})';
-      // tether-countries="NL,DE,BE": only these (in your order); otherwise every country of the store.
-      const only = (s.getAttribute(attr('countries')) || '').toUpperCase().split(/[\s,]+/).filter(Boolean);
-      const list = only.length ? only.map((c) => countries.find((x) => x.isoCode === c)).filter(Boolean) : countries;
-      s.innerHTML = '';
-      list.forEach((c) => s.appendChild(new Option(fill(tpl, c), c.isoCode)));
-      s.value = current;
-      if (s.value !== current) s.selectedIndex = -1; // a country the store doesn't sell to
-      s.disabled = list.length < 2 && !s.hasAttribute(attr('always-enabled'));
-    });
-    binds.forEach((el) => {
-      const k = get(el, 'country-bind') || 'name';
-      const v = { name: info?.name, code: info?.isoCode, currency: info?.currency?.isoCode, symbol: info?.currency?.symbol }[k];
-      el.textContent = v || '';
-    });
-  }).catch((err) => reportError(err, 'country select'));
-}
-
-/**
- * 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' })
- */
-export async function setCountry(code, { language, locale, remember = true } = {}) {
-  const country = toCountry(code);
-  if (!country) throw new TetherError(`Not a country code: ${code}`, { code: 'INVALID_COUNTRY' });
-  // Money format: the option, else a markets.locales entry for this country, else unchanged.
-  const entry = Object.values(cfg.markets?.locales || {}).find((m) => toCountry(m?.country) === country);
-  const own = locale || entry?.locale;
-  const loc = own || cfg.locale;
-  // Language: the option, else the markets.locales entry for this country (which may have none), else unchanged.
-  const lang = language !== undefined ? toLanguage(language) : entry ? (entry.language ? toLanguage(entry.language) : undefined) : cfg.language;
-  const changed = country !== String(cfg.country || '').toUpperCase() || lang !== cfg.language || loc !== cfg.locale;
-  cfg.country = country;
-  cfg.language = lang || undefined;
-  cfg.locale = loc;
-  if (remember) rememberMarket({ country, language: lang, locale: own });
-  if (!changed) { renderCountrySelects(); return Cart.state; }
-
-  clearProductCache();
-  const jobs = [];
-  if (language !== undefined) clearLocalization(); // country names follow the language
-  // Only an existing cart moves; switching country never creates one.
-  if (Cart.id()) jobs.push(Cart.setBuyerIdentity({ countryCode: country }, { create: false }).catch((err) => reportError(err, 'cart country')));
-
-  pruneLive();
-  liveLists.forEach((list) => jobs.push(list.load()));
-  liveProducts.forEach((el) => {
-    if (el.closest(listSelector())) return; // re-rendered by its list
-    mountedProducts.delete(el);
-    mountProduct(el);
-  });
-
-  renderCountrySelects();
-  emit('country-changed', { country, language: cfg.language });
-  await Promise.all(jobs);
-  return Cart.state;
-}
-

package/src/markets.js

@@ -1,133 +0,0 @@
-/**
- * Markets: which country/language prices, currency and translations follow.
- *
- *   markets: {
- *     detect: true,                       // or a list: ['saved', 'server', 'webflow']
- *     locales: {                          // Webflow Localization: locale subdirectory or <html lang>
- *       de: { country: 'DE', language: 'DE', locale: 'de-DE' },
- *       'fr-be': { country: 'BE', language: 'FR' },
- *     },
- *     cookie: 'tether_country',           // a cookie your server/Worker sets (e.g. from cf-ipcountry)
- *     remember: true,                     // keep the visitor's tether-country-select choice
- *   }
- *
- * Sources, first match wins per field:
- *   saved   the visitor's own choice (localStorage), from tether-country-select / Tether.setCountry()
- *   server  window.TETHER_COUNTRY, <meta name="tether-country" content="DE">, or the cookie
- *   webflow locale subdirectory (/de/...) or <html lang="de-DE">, through `locales`
- * then the static `country` / `language` config. Without `detect`, only `saved` applies
- * (so a country select keeps working across pages); `detect: false` turns even that off. Tether never calls an IP lookup service:
- * a country from the visitor's IP only comes from your own server (see README).
- */
-import { cfg } from './config.js';
-import { gql } from './client.js';
-
-const COUNTRY = /^[A-Z]{2}$/;
-// Shopify LanguageCode values with a region; others are the plain ISO 639-1 code.
-const REGIONAL_LANGUAGES = new Set(['PT_BR', 'PT_PT', 'ZH_CN', 'ZH_TW']);
-
-export const storageKey = () => `${cfg.prefix}:market:${cfg.domain}`;
-
-const defaultEnv = () => ({
-  document: typeof document !== 'undefined' ? document : null,
-  location: typeof window !== 'undefined' ? window.location : null,
-  storage: (() => { try { return window.localStorage; } catch { return null; } })(),
-  global: typeof window !== 'undefined' ? window : {},
-});
-
-export function toCountry(v) {
-  const c = String(v || '').trim().toUpperCase();
-  return COUNTRY.test(c) && c !== 'XX' && c !== 'T1' ? c : null; // XX/T1: Cloudflare's unknown/Tor
-}
-
-/** 'de-DE' -> 'DE', 'pt-BR' -> 'PT_BR', 'en' -> 'EN'. */
-export function toLanguage(v) {
-  const raw = String(v || '').trim().replace('-', '_').toUpperCase();
-  if (!raw) return null;
-  if (REGIONAL_LANGUAGES.has(raw)) return raw;
-  const primary = raw.split('_')[0];
-  return /^[A-Z]{2,3}$/.test(primary) ? primary : null;
-}
-
-function readCookie(doc, name) {
-  if (!doc || !name) return null;
-  const hit = String(doc.cookie || '').split(';').map((c) => c.trim()).find((c) => c.startsWith(`${name}=`));
-  return hit ? decodeURIComponent(hit.slice(name.length + 1)) : null;
-}
-
-const lookup = (locales, key) => {
-  if (!locales || !key) return null;
-  const k = String(key).toLowerCase();
-  const found = Object.keys(locales).find((x) => x.toLowerCase() === k);
-  return found ? locales[found] : null;
-};
-
-const readers = {
-  saved(m, env) {
-    if (m.remember === false || !env.storage) return null;
-    try { return JSON.parse(env.storage.getItem(storageKey()) || 'null'); } catch { return null; }
-  },
-  server(m, env) {
-    const meta = (name) => env.document?.querySelector?.(`meta[name="${name}"]`)?.getAttribute('content');
-    const country = env.global.TETHER_COUNTRY || meta('tether-country') || readCookie(env.document, m.cookie || 'tether_country');
-    const language = env.global.TETHER_LANGUAGE || meta('tether-language');
-    return { country, language };
-  },
-  webflow(m, env) {
-    const segment = (env.location?.pathname || '/').split('/').filter(Boolean)[0];
-    const fromPath = lookup(m.locales, segment);
-    if (fromPath) return fromPath;
-    const lang = env.document?.documentElement?.getAttribute('lang');
-    if (!lang) return null;
-    const mapped = lookup(m.locales, lang) || lookup(m.locales, lang.split('-')[0]);
-    if (mapped) return { locale: lang, ...mapped };
-    if (m.locales && m.strict) return null;
-    // Unmapped: language from <html lang>, country only from a region subtag (de-CH -> CH).
-    const region = lang.split('-')[1];
-    return { language: lang, country: region && region.length === 2 ? region : null, locale: lang };
-  },
-};
-
-/**
- * Returns { country, language, locale, sources } with only the fields found.
- * Pure apart from reading the DOM/storage: easy to test.
- */
-export function detectMarket(markets = cfg.markets, env = defaultEnv()) {
-  const m = markets || {};
-  if (m.detect === false) return {};
-  // Without detect, only the visitor's own choice (from a country select) is applied.
-  const list = !m.detect ? ['saved'] : m.detect === true ? ['saved', 'server', 'webflow'] : [].concat(m.detect);
-  markets = m;
-  const out = { sources: {} };
-  list.forEach((name) => {
-    const r = readers[name]?.(markets, env);
-    if (!r) return;
-    const vals = { country: toCountry(r.country), language: toLanguage(r.language), locale: r.locale || null };
-    Object.entries(vals).forEach(([k, v]) => {
-      if (v && !out[k]) { out[k] = v; out.sources[k] = name; }
-    });
-  });
-  return out;
-}
-
-export function rememberMarket(market) {
-  if (cfg.markets?.remember === false) return;
-  try { localStorage.setItem(storageKey(), JSON.stringify({ country: market.country, language: market.language || undefined, locale: market.locale || undefined })); } catch { /* private mode */ }
-}
-
-let localizationPromise = null;
-export function clearLocalization() { localizationPromise = null; }
-
-/** Countries the store sells to (Shopify Markets), with currency. Cached per page. */
-export function getLocalization() {
-  if (!localizationPromise) {
-    localizationPromise = gql(`query TetherLocalization {
-  localization {
-    country { isoCode name currency { isoCode symbol } }
-    language { isoCode name }
-    availableCountries { isoCode name currency { isoCode symbol } availableLanguages { isoCode name } }
-  }
-}`).then((d) => d.localization).catch((err) => { localizationPromise = null; throw err; });
-  }
-  return localizationPromise;
-}

package/src/mounting.js

@@ -1,154 +0,0 @@
-/** Product scopes and lists that are mounted, shared by index.js and the optional markets part. */
-import { cfg, log, warn, reportError } from './config.js';
-import { ProductScope, scopes, rememberOptionNames } from './product.js';
-import { listSelector } from './collection.js';
-import { getProduct, takeStale, refreshProducts, hydrateProducts } from './loader.js';
-import { resolveProductKey, setScopeStatus, isNotFound } from './status.js';
-import { attr, get, qsa, emit } from './dom.js';
-
-export const mountedProducts = new WeakSet();
-export const mountedLists = new WeakSet();
-// Live roots, for re-rendering after a country switch (pruned when disconnected).
-export const liveProducts = new Set();
-export const liveLists = new Set();
-const requestToken = new WeakMap(); // product root -> latest request, so a slow old response can't win
-
-export function pruneLive() {
-  liveProducts.forEach((el) => { if (!el.isConnected) liveProducts.delete(el); });
-  liveLists.forEach((l) => { if (!l.root.isConnected) liveLists.delete(l); });
-}
-export function within(root, selector) {
-  return [...(root.matches?.(selector) ? [root] : []), ...qsa(root, selector)];
-}
-
-export /** Mounts one product root. Returns true when a product request was started. */
-function mountProduct(el) {
-  if (mountedProducts.has(el)) return false;
-  const { key, fromUrl, raw } = resolveProductKey(el);
-  if (!key) {
-    if (fromUrl) {
-      // Dynamic product page opened without ?handle= (or an empty path).
-      mountedProducts.add(el);
-      setScopeStatus(el, 'not-found');
-      emit('product-not-found', { key: null, source: raw }, el);
-    } else if (!el.closest(listSelector())) {
-      // List cards get their handle when the list renders.
-      warn(`[${attr('product')}] without a value. Bind it to the Shopify handle field, or use "url:handle".`, el);
-    }
-    return false;
-  }
-  mountedProducts.add(el);
-  liveProducts.add(el);
-  const token = {};
-  requestToken.set(el, token);
-  const current = () => requestToken.get(el) === token;
-  // A rendered scope keeps showing its content while it refreshes (e.g. country switch).
-  if (!scopes.get(el)) setScopeStatus(el, 'loading');
-  else el.setAttribute(attr('state'), 'updating');
-  const loading = getProduct(key);
-  marketPending?.add(loading);
-  loading
-    .then((p) => {
-      if (!current()) return;
-      const existing = scopes.get(el);
-      if (existing) existing.update(p);
-      // eslint-disable-next-line no-new
-      else new ProductScope(el, p);
-      applyPageTitle(el, p);
-      if (cfg.revalidate !== false && takeStale(key)) queueRefresh(key);
-    })
-    .catch((err) => {
-      if (!current()) return;
-      const notFound = isNotFound(err);
-      setScopeStatus(el, notFound ? 'not-found' : 'error', err);
-      if (notFound) {
-        emit('product-not-found', { key, source: raw }, el);
-        // A typo in a URL isn't worth an alert; a CMS item pointing at a deleted product is.
-        if (fromUrl) log(`product not found: ${key}`); else reportError(err, `product ${key}`);
-      } else {
-        reportError(err, `product ${key}`);
-        emit('error', { error: err, context: 'product', key }, el);
-      }
-    });
-  return true;
-}
-
-/** tether-page-title="{title} | My shop" on a product root sets document.title (dynamic product pages). */
-function applyPageTitle(el, p) {
-  const tpl = get(el, 'page-title');
-  if (!tpl || typeof document === 'undefined') return;
-  document.title = tpl.replace(/\{title\}/g, p.title).replace(/\{vendor\}/g, p.vendor || '').replace(/\{type\}/g, p.productType || '');
-}
-
-
-/** Product scopes that failed on a network/API error: loaded again when the browser is back online. */
-export function retryFailed() {
-  pruneLive();
-  liveProducts.forEach((el) => {
-    if (el.getAttribute(attr('state')) !== 'error' || el.getAttribute(attr('error')) === 'not-found') return;
-    mountedProducts.delete(el);
-    mountProduct(el);
-  });
-}
-
-// Server-rendered products: one batched background request refreshes them all.
-let refreshQueue = new Set();
-function queueRefresh(key) {
-  if (!refreshQueue.size) setTimeout(flushRefresh, 0);
-  refreshQueue.add(key);
-}
-function flushRefresh() {
-  const keys = [...refreshQueue];
-  refreshQueue = new Set();
-  refreshProducts(keys).forEach((promise, i) => promise.then((fresh) => {
-    liveProducts.forEach((el) => {
-      const scope = scopes.get(el);
-      if (!scope || !el.isConnected) return;
-      const k = resolveProductKey(el).key;
-      if (k !== keys[i] && k !== fresh.handle && k !== fresh.id) return;
-      if (JSON.stringify(scope.product) !== JSON.stringify(fresh)) scope.update(fresh);
-    });
-  }).catch((err) => reportError(err, `refresh ${keys[i]}`)));
-}
-
-/**
- * <script type="application/json" data-tether-hydrate> tags written by tether/server's hydrate():
- * their products are used without a request. Ignored when they were made for another market.
- */
-const readScripts = new WeakSet();
-let marketPending = null; // product loads to wait for before html.tether-market-pending goes
-
-/** Lists (and anything else that loads prices) wait too. */
-export const trackMarket = (p) => { marketPending?.add(p); return p; };
-
-/** After a mount: drop html.tether-market-pending once this page's products are live. */
-export function settleMarket() {
-  if (!marketPending) return;
-  const waits = [...marketPending];
-  Promise.allSettled(waits).then(() => {
-    if (!marketPending || waits.some((w) => !marketPending.has(w))) return;
-    if (waits.length === marketPending.size) {
-      marketPending = null;
-      document.documentElement.classList.remove(`${cfg.prefix}-market-pending`);
-    } else settleMarket(); // more products came in meanwhile
-  });
-}
-
-export function hydrateFromPage(root = document) {
-  qsa(root.ownerDocument || root, 'script[type="application/json"][data-tether-hydrate]').forEach((s) => {
-    if (readScripts.has(s)) return;
-    readScripts.add(s);
-    try {
-      const data = JSON.parse(s.textContent);
-      rememberOptionNames(data.products); // the build's option names, also for other languages
-      const same = (a, b) => String(a || '').toUpperCase() === String(b || '').toUpperCase();
-      if (same(data.country, cfg.country) && same(data.language, cfg.language)) hydrateProducts(data.products);
-      else {
-        // The page was built for another market: its prices aren't this visitor's. Mark the page
-        // (html.tether-market-pending) until the live ones are in, so CSS can hide prices meanwhile.
-        log('hydration skipped: other market');
-        if (!marketPending) { marketPending = new Set(); document.documentElement.classList.add(`${cfg.prefix}-market-pending`); }
-      }
-    } catch (err) { warn('bad data-tether-hydrate', err); }
-  });
-}

package/src/parts/account-pages.js

@@ -1,3 +0,0 @@
-import * as part from '../account-pages.js';
-
-window.Tether.__parts['account-pages'] = part;

package/src/parts/account.js

@@ -1,3 +0,0 @@
-import * as part from '../account.js';
-
-window.Tether.__parts.account = part;

package/src/parts/analytics.js

@@ -1,3 +0,0 @@
-import * as part from '../analytics.js';
-
-window.Tether.__parts.analytics = part;

package/src/parts/diagnose.js

@@ -1,3 +0,0 @@
-import * as part from '../diagnose.js';
-
-window.Tether.__parts.diagnose = part;

package/src/parts/extras.js

@@ -1,3 +0,0 @@
-import * as part from '../extras.js';
-
-window.Tether.__parts.extras = part;

package/src/parts/markets.js

@@ -1,3 +0,0 @@
-import * as part from '../markets-ui.js';
-
-window.Tether.__parts.markets = part;

package/src/parts/search.js

@@ -1,3 +0,0 @@
-import * as part from '../search.js';
-
-window.Tether.__parts.search = part;