@occluze/tether 0.6.8 → 0.7.1

package/src/markets.js

@@ -1,334 +0,0 @@
-/**
- * Markets: which country and 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 or Worker sets (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 the site's own server (see README).
- */
-import { cfg } from './config.js';
-import { gql } from './client.js';
-import { toCountry, toLanguage } from './market-codes.js';
-/** @import { MarketsConfig } from './config.js' */
-/** @import { CountryCode, LanguageCode } from './market-codes.js' */
-
-/**
- * @typedef {object} Market A market a visitor chose, as `setCountry()` stores it.
- * @property {CountryCode} country
- * @property {LanguageCode | undefined} language
- * @property {string | undefined} locale An `Intl` locale for money and dates.
- */
-
-/** @typedef {'saved' | 'server' | 'webflow'} MarketSource */
-/** @typedef {'country' | 'language' | 'locale'} MarketField */
-/** @typedef {Partial<Record<MarketField, MarketSource>>} MarketSources */
-
-/**
- * @typedef {object} DetectedMarket The fields detection found, and the source each came from.
- * @property {CountryCode} [country]
- * @property {LanguageCode} [language]
- * @property {string} [locale]
- * @property {MarketSources} [sources] Absent when `detect: false` turns detection off.
- */
-
-/**
- * @typedef {object} MarketEnv What detection reads, passed in so it runs on any document.
- * @property {Pick<Document, 'cookie' | 'querySelector' | 'documentElement'> | null} document
- * @property {Pick<Location, 'pathname'> | null} location
- * @property {Pick<Storage, 'getItem'> | null} storage
- * @property {object} global Where `TETHER_COUNTRY` and `TETHER_LANGUAGE` are read from (`window`).
- */
-
-/** @typedef {{ country?: unknown, language?: unknown, locale?: unknown }} MarketHint A source's raw values. */
-
-/** @typedef {{ isoCode: string, name: string }} NamedCode */
-/** @typedef {{ isoCode: string, symbol: string }} Currency */
-/** @typedef {NamedCode & { currency: Currency }} LocalizedCountry */
-/**
- * @typedef {object} Localization The store's markets, from the Storefront API's `localization`.
- * @property {LocalizedCountry} country The country of the current `@inContext`.
- * @property {NamedCode} language
- * @property {(LocalizedCountry & { availableLanguages: NamedCode[] })[]} availableCountries
- */
-
-/** @type {readonly MarketSource[]} */
-const ALL_SOURCES = ['saved', 'server', 'webflow'];
-const DEFAULT_COOKIE = 'tether_country';
-
-/** @returns {string} The localStorage key of the visitor's market: `<prefix>:market:<domain>`. */
-export const storageKey = () => `${cfg.prefix}:market:${cfg.domain}`;
-
-/**
- * Accessing `localStorage` throws where the browser blocks storage (sandboxed frames, cookies turned off); the visitor
- * then simply has no saved market.
- *
- * @returns {Storage | null}
- */
-function localStorageIfAllowed() {
-  if (typeof window === 'undefined') return null;
-  try {
-    return window.localStorage;
-  } catch {
-    return null;
-  }
-}
-
-/** @returns {MarketEnv} The page this script runs on. */
-function pageEnv() {
-  const hasWindow = typeof window !== 'undefined';
-  return {
-    document: typeof document !== 'undefined' ? document : null,
-    location: hasWindow ? window.location : null,
-    storage: localStorageIfAllowed(),
-    global: hasWindow ? window : {},
-  };
-}
-
-/**
- * @param {string} text
- * @returns {unknown} The JSON value, `null` for text that isn't JSON (a key another script wrote).
- */
-function parseJsonOrNull(text) {
-  try {
-    return /** @type {unknown} */ (JSON.parse(text));
-  } catch (error) {
-    if (error instanceof SyntaxError) return null;
-    throw error;
-  }
-}
-
-/**
- * @param {unknown} value
- * @returns {Market | null} `value` as a market, when it has a valid country. A language or locale that isn't valid is
- *   left out.
- */
-function toMarket(value) {
-  if (typeof value !== 'object' || value === null) return null;
-  const country = toCountry(Reflect.get(value, 'country'));
-  if (!country) return null;
-  const locale = /** @type {unknown} */ (Reflect.get(value, 'locale'));
-  return {
-    country,
-    language: toLanguage(Reflect.get(value, 'language')) ?? undefined,
-    locale: typeof locale === 'string' && locale ? locale : undefined,
-  };
-}
-
-/**
- * The visitor's saved market (`setCountry()`, `tether-country-select`), validated: storage is written by other tabs,
- * older versions and other scripts too.
- *
- * @param {Pick<Storage, 'getItem'> | null} [storage] Default `localStorage`, `null` where the browser blocks it.
- * @returns {Market | null} `null` when nothing valid is saved.
- */
-export function readSavedMarket(storage = localStorageIfAllowed()) {
-  const text = storage?.getItem(storageKey());
-  return text ? toMarket(parseJsonOrNull(text)) : null;
-}
-
-/**
- * @param {Pick<Document, 'cookie'> | null} doc
- * @param {string} name
- * @returns {string | null}
- */
-function readCookie(doc, name) {
-  if (!doc || !name) return null;
-  const cookie = doc.cookie
-    .split(';')
-    .map((part) => part.trim())
-    .find((part) => part.startsWith(`${name}=`));
-  return cookie ? decodeURIComponent(cookie.slice(name.length + 1)) : null;
-}
-
-/**
- * @param {MarketsConfig['locales']} locales
- * @param {string | undefined} key
- * @returns {MarketHint | null} The entry for `key`, ignoring case.
- */
-function lookupLocale(locales, key) {
-  if (!locales || !key) return null;
-  const wanted = key.toLowerCase();
-  const found = Object.keys(locales).find((name) => name.toLowerCase() === wanted);
-  return found ? (locales[found] ?? null) : null;
-}
-
-/**
- * @param {MarketsConfig} markets
- * @param {MarketEnv} env
- * @returns {MarketHint}
- */
-function readServerHint(markets, env) {
-  /** @param {string} name */
-  const meta = (name) => env.document?.querySelector(`meta[name="${name}"]`)?.getAttribute('content');
-  return {
-    country:
-      Reflect.get(env.global, 'TETHER_COUNTRY') ||
-      meta('tether-country') ||
-      readCookie(env.document, markets.cookie || DEFAULT_COOKIE),
-    language: Reflect.get(env.global, 'TETHER_LANGUAGE') || meta('tether-language'),
-  };
-}
-
-/**
- * @param {MarketsConfig} markets
- * @param {MarketEnv} env
- * @returns {MarketHint | null}
- */
-function readWebflowLocale(markets, env) {
-  const segment = (env.location?.pathname ?? '/').split('/').find((part) => part !== '');
-  const fromPath = lookupLocale(markets.locales, segment);
-  if (fromPath) return fromPath;
-  const lang = env.document?.documentElement.getAttribute('lang');
-  if (!lang) return null;
-  const mapped = lookupLocale(markets.locales, lang) ?? lookupLocale(markets.locales, lang.split('-')[0]);
-  if (mapped) return { locale: lang, ...mapped };
-  if (markets.locales && markets.strict) return null;
-  // Unmapped: the language from <html lang>, a country only from a region subtag (de-CH -> CH).
-  const region = lang.split('-')[1];
-  return { language: lang, country: region?.length === 2 ? region : null, locale: lang };
-}
-
-/**
- * @param {MarketSource} source
- * @param {MarketsConfig} markets
- * @param {MarketEnv} env
- * @returns {MarketHint | null}
- */
-function readSource(source, markets, env) {
-  switch (source) {
-    case 'saved':
-      return markets.remember === false ? null : readSavedMarket(env.storage);
-    case 'server':
-      return readServerHint(markets, env);
-    case 'webflow':
-      return readWebflowLocale(markets, env);
-  }
-}
-
-/**
- * @param {unknown} name
- * @returns {name is MarketSource}
- */
-const isMarketSource = (name) => ALL_SOURCES.some((source) => source === name);
-
-/**
- * @param {MarketsConfig['detect']} detect
- * @returns {readonly MarketSource[]} Without `detect`, only the visitor's own choice from a country select.
- */
-function sourcesFor(detect) {
-  if (!detect) return ['saved'];
-  if (detect === true) return ALL_SOURCES;
-  // The config comes from the page unvalidated, so a single name or an unknown one can arrive here.
-  return /** @type {unknown[]} */ ([detect].flat()).filter(isMarketSource);
-}
-
-/**
- * The market the page's sources point to. Reads the DOM and storage only, so it can run on any `env`.
- *
- * @param {MarketsConfig | null | undefined} [markets]
- * @param {MarketEnv} [env]
- * @returns {DetectedMarket} Only the fields found; `{}` with `detect: false`.
- */
-export function detectMarket(markets = cfg.markets, env = pageEnv()) {
-  const config = markets ?? {};
-  if (config.detect === false) return {};
-  /** @type {MarketSources} */
-  const sources = {};
-  /** @type {DetectedMarket} */
-  const found = { sources };
-  for (const source of sourcesFor(config.detect)) {
-    const hint = readSource(source, config, env);
-    if (!hint) continue;
-    const country = toCountry(hint.country);
-    const language = toLanguage(hint.language);
-    const locale = typeof hint.locale === 'string' && hint.locale ? hint.locale : null;
-    if (country && !found.country) {
-      found.country = country;
-      sources.country = source;
-    }
-    if (language && !found.language) {
-      found.language = language;
-      sources.language = source;
-    }
-    if (locale && !found.locale) {
-      found.locale = locale;
-      sources.locale = source;
-    }
-  }
-  return found;
-}
-
-/**
- * `setItem` throws when storage is full or blocked (Safari's private mode); the choice then lasts for this page only.
- *
- * @param {string} key
- * @param {string} value
- */
-function storeIfAllowed(key, value) {
-  try {
-    localStorage.setItem(key, value);
-  } catch {
-    return;
-  }
-}
-
-/**
- * Saves the visitor's choice for the next pages, unless `markets.remember` is false.
- *
- * @param {{ country: CountryCode, language?: string | null | undefined, locale?: string | null | undefined }} market
- */
-export function rememberMarket(market) {
-  if (cfg.markets?.remember === false) return;
-  const saved = { country: market.country, language: market.language || undefined, locale: market.locale || undefined };
-  storeIfAllowed(storageKey(), JSON.stringify(saved));
-}
-
-/** @type {Promise<Localization> | null} */
-let localizationPromise = null;
-
-/** Forgets the cached localization, for when country names change language. */
-export function clearLocalization() {
-  localizationPromise = null;
-}
-
-const LOCALIZATION_QUERY = `query TetherLocalization {
-  localization {
-    country { isoCode name currency { isoCode symbol } }
-    language { isoCode name }
-    availableCountries { isoCode name currency { isoCode symbol } availableLanguages { isoCode name } }
-  }
-}`;
-
-/**
- * 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.
- *
- * @returns {Promise<Localization>}
- */
-export function getLocalization() {
-  if (!localizationPromise) {
-    /** @type {Promise<{ localization: Localization }>} */
-    const loading = gql(LOCALIZATION_QUERY);
-    localizationPromise = loading.then(
-      (data) => data.localization,
-      (/** @type {unknown} */ error) => {
-        localizationPromise = null;
-        throw error;
-      },
-    );
-  }
-  return localizationPromise;
-}

package/src/markup.js

@@ -1,64 +0,0 @@
-/**
- * How Tether finds its markup: attribute names carry the configured prefix (`tether-product`, or `wfs-product` with
- * `prefix: 'wfs'`), and so do the selectors and the DOM events built from them.
- */
-import { cfg } from './config.js';
-
-/**
- * @param {string} name
- * @returns {string} The prefixed attribute name: `product` → `tether-product`.
- */
-export const attr = (name) => `${cfg.prefix}-${name}`;
-
-/**
- * @param {string} name
- * @param {string} [value]
- * @returns {string} A selector for the attribute, with that exact value when given.
- */
-export const sel = (name, value) => (value === undefined ? `[${attr(name)}]` : `[${attr(name)}="${value}"]`);
-
-/**
- * @param {Element} el
- * @param {string} name
- */
-export const get = (el, name) => el.getAttribute(attr(name));
-
-/**
- * @param {Element} el
- * @param {string} name
- */
-export const has = (el, name) => el.hasAttribute(attr(name));
-
-/**
- * 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.
- *
- * @param {ParentNode | null | undefined} root
- * @param {string} selector
- * @returns {HTMLElement[]} The matches in `root`, none without a root.
- */
-export function qsa(root, selector) {
-  if (!root) return [];
-  return [.../** @type {NodeListOf<HTMLElement>} */ (root.querySelectorAll(selector))];
-}
-
-/**
- * @param {Element | null | undefined} root
- * @param {string} selector
- * @param {string} scopeSelector
- * @returns {HTMLElement[]} Matches in `root` whose nearest `scopeSelector` ancestor is `root` itself, not a nested
- *   scope.
- */
-export const scoped = (root, selector, scopeSelector) =>
-  qsa(root, selector).filter((el) => el.closest(scopeSelector) === root);
-
-/**
- * Dispatches the bubbling event `<prefix>:<name>`.
- *
- * @param {string} name
- * @param {unknown} [detail]
- * @param {EventTarget} [target]
- */
-export function emit(name, detail, target = document) {
-  target.dispatchEvent(new CustomEvent(`${cfg.prefix}:${name}`, { detail, bubbles: true }));
-}

package/src/mounting.js

@@ -1,277 +0,0 @@
-/**
- * The product scopes and lists on the page: mounting a product root, the live roots a country switch re-renders, and
- * the products the server rendered into the page. 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';
-/** @import { Product } from './fragments.js' */
-
-/** @typedef {{ root: Element, load: (more?: boolean) => Promise<unknown> }} MountedList A mounted `ListScope`. */
-
-/**
- * The marker on the `<script type="application/json">` tags `tether/server`'s `hydrate()` writes. It is fixed, not
- * `<prefix>-hydrate`, because the server writes it without knowing the browser's prefix.
- */
-const HYDRATE_SELECTOR = 'script[type="application/json"][data-tether-hydrate]';
-
-/** @type {WeakSet<Element>} */
-export const mountedProducts = new WeakSet();
-/** @type {WeakSet<Element>} */
-export const mountedLists = new WeakSet();
-/** @type {Set<HTMLElement>} Product roots to re-render after a country switch; pruned once disconnected. */
-export const liveProducts = new Set();
-/** @type {Set<MountedList>} Lists to reload after a country switch; pruned once disconnected. */
-export const liveLists = new Set();
-/** @type {WeakMap<Element, object>} Each product root's latest request, so a slow older response can't win. */
-const latestRequest = new WeakMap();
-
-/** Forgets roots a page transition removed, so they aren't kept alive. */
-export function pruneLive() {
-  liveProducts.forEach((el) => {
-    if (!el.isConnected) liveProducts.delete(el);
-  });
-  liveLists.forEach((list) => {
-    if (!list.root.isConnected) liveLists.delete(list);
-  });
-}
-
-/**
- * @param {ParentNode & Partial<Pick<Element, 'matches'>>} root
- * @param {string} selector
- * @returns {HTMLElement[]} `root` itself when it matches, then the matches inside it.
- */
-export function within(root, selector) {
-  const self = root.matches?.(selector) ? [/** @type {HTMLElement} */ (root)] : [];
-  return [...self, ...qsa(root, selector)];
-}
-
-/**
- * `tether-page-title="{title} | My shop"` on a product root sets `document.title`, for dynamic product pages.
- *
- * @param {Element} el
- * @param {Product} product
- */
-function applyPageTitle(el, product) {
-  const template = get(el, 'page-title');
-  if (!template || typeof document === 'undefined') return;
-  document.title = template
-    .replace(/\{title\}/g, product.title)
-    .replace(/\{vendor\}/g, product.vendor || '')
-    .replace(/\{type\}/g, product.productType || '');
-}
-
-/**
- * A product root without a key: on a dynamic page opened without `?handle=` (or with an empty path) it is a product
- * that isn't there; inside a list it gets its handle when the list renders.
- *
- * @param {HTMLElement} el
- * @param {{ fromUrl: boolean, raw: string }} source
- */
-function mountWithoutKey(el, { fromUrl, raw }) {
-  if (fromUrl) {
-    mountedProducts.add(el);
-    setScopeStatus(el, 'not-found');
-    emit('product-not-found', { key: null, source: raw }, el);
-  } else if (!el.closest(listSelector())) {
-    warn(`[${attr('product')}] without a value. Bind it to the Shopify handle field, or use "url:handle".`, el);
-  }
-}
-
-/**
- * @param {HTMLElement} el
- * @param {string} key
- * @param {{ fromUrl: boolean, raw: string }} source
- * @param {unknown} error
- */
-function showLoadFailure(el, key, { fromUrl, raw }, error) {
-  const notFound = isNotFound(error);
-  setScopeStatus(el, notFound ? 'not-found' : 'error', error);
-  if (!notFound) {
-    reportError(error, `product ${key}`);
-    emit('error', { error, context: 'product', key }, el);
-    return;
-  }
-  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(error, `product ${key}`);
-}
-
-/**
- * Mounts one product root.
- *
- * @param {HTMLElement} el
- * @returns {boolean} True when a product request was started.
- */
-export function mountProduct(el) {
-  if (mountedProducts.has(el)) return false;
-  const { key, ...source } = resolveProductKey(el);
-  if (!key) {
-    mountWithoutKey(el, source);
-    return false;
-  }
-  mountedProducts.add(el);
-  liveProducts.add(el);
-  const request = {};
-  latestRequest.set(el, request);
-  const isLatest = () => latestRequest.get(el) === request;
-  // A rendered scope keeps showing its content while it refreshes (a country switch).
-  if (scopes.get(el)) el.setAttribute(attr('state'), 'updating');
-  else setScopeStatus(el, 'loading');
-  const loading = trackMarket(getProduct(key));
-  loading
-    .then((product) => {
-      if (!isLatest()) return;
-      const existing = scopes.get(el);
-      if (existing) existing.update(product);
-      else new ProductScope(el, product);
-      applyPageTitle(el, product);
-      if (cfg.revalidate && takeStale(key)) queueRefresh(key);
-    })
-    .catch((/** @type {unknown} */ error) => {
-      if (isLatest()) showLoadFailure(el, key, source, error);
-    });
-  return true;
-}
-
-/** Loads again the product scopes that failed on a network or API error, for 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);
-  });
-}
-
-/** @type {Set<string>} Server-rendered products to refresh in the next batch. */
-let refreshQueue = new Set();
-
-/** @param {string} key */
-function queueRefresh(key) {
-  if (!refreshQueue.size) setTimeout(flushRefresh, 0);
-  refreshQueue.add(key);
-}
-
-/**
- * @param {string} key The key the refresh was asked for.
- * @param {Product} fresh
- */
-function applyRefresh(key, fresh) {
-  liveProducts.forEach((el) => {
-    const scope = scopes.get(el);
-    if (!scope || !el.isConnected) return;
-    const rootKey = resolveProductKey(el).key;
-    if (rootKey !== key && rootKey !== fresh.handle && rootKey !== fresh.id) return;
-    if (JSON.stringify(scope.product) !== JSON.stringify(fresh)) scope.update(fresh);
-  });
-}
-
-/** One batched background request refreshes every server-rendered product queued. */
-function flushRefresh() {
-  const keys = [...refreshQueue];
-  refreshQueue = new Set();
-  refreshProducts(keys).forEach((promise, index) => {
-    const key = /** @type {string} */ (keys[index]);
-    promise
-      .then((fresh) => {
-        applyRefresh(key, fresh);
-      })
-      .catch((/** @type {unknown} */ error) => {
-        reportError(error, `refresh ${key}`);
-      });
-  });
-}
-
-/**
- * @type {Set<Promise<unknown>> | null} While the page's server-rendered prices are another market's: the loads to
- *   wait for before `html.tether-market-pending` goes. `null` when no market is pending.
- */
-let marketPending = null;
-
-/**
- * Lists, and anything else that loads prices, hold `html.tether-market-pending` until they are in.
- *
- * @template T
- * @param {Promise<T>} loading
- * @returns {Promise<T>} `loading` itself.
- */
-export const trackMarket = (loading) => {
-  marketPending?.add(loading);
-  return loading;
-};
-
-/** After a mount: drops `html.tether-market-pending` once this page's products are live. */
-export function settleMarket() {
-  if (!marketPending) return;
-  const waits = [...marketPending];
-  void Promise.allSettled(waits).then(() => {
-    if (!marketPending || waits.some((wait) => !marketPending?.has(wait))) return;
-    if (waits.length !== marketPending.size) {
-      settleMarket(); // more loads came in meanwhile
-      return;
-    }
-    marketPending = null;
-    document.documentElement.classList.remove(`${cfg.prefix}-market-pending`);
-  });
-}
-
-/**
- * What `tether/server`'s `hydrate()` writes. The tag is the site's own markup, so its shape is trusted; a product
- * without an id or a handle is skipped.
- *
- * @typedef {{ country?: string | null, language?: string | null, products?: (Product | null)[] }} HydratePayload
- */
-
-/**
- * @param {Product | null} product
- * @returns {product is Product}
- */
-const isUsable = (product) => Boolean(product?.id && product.handle);
-
-/**
- * @param {string | null | undefined} a
- * @param {string | null | undefined} b
- */
-const sameCode = (a, b) => (a ?? '').toUpperCase() === (b ?? '').toUpperCase();
-
-/** @type {WeakSet<Element>} Hydrate tags already read. */
-const readScripts = new WeakSet();
-
-/**
- * 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.
- *
- * @param {Document | Element} [root]
- */
-export function hydrateFromPage(root = document) {
-  qsa(root.ownerDocument ?? root, HYDRATE_SELECTOR).forEach((script) => {
-    if (readScripts.has(script)) return;
-    readScripts.add(script);
-    /** @type {unknown} */
-    let json;
-    try {
-      json = JSON.parse(script.textContent);
-    } catch (error) {
-      warn('bad data-tether-hydrate', error);
-      return;
-    }
-    const { country, language, products } = /** @type {HydratePayload | null} */ (json) ?? {};
-    const usable = Array.isArray(products) ? products.filter(isUsable) : [];
-    rememberOptionNames(usable); // the build's option names, also for other languages
-    if (sameCode(country, cfg.country) && sameCode(language, cfg.language)) {
-      hydrateProducts(usable);
-      return;
-    }
-    log('hydration skipped: other market');
-    if (!marketPending) {
-      marketPending = new Set();
-      document.documentElement.classList.add(`${cfg.prefix}-market-pending`);
-    }
-  });
-}