@occluze/tether 0.6.7 → 0.7.0

package/dist/tether.account.js

@@ -5,21 +5,18 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // src/account.js
+  // src/account.ts
   var account_exports = {};
   __export(account_exports, {
     addresses: () => addresses,
     customer: () => customer,
     deleteAddress: () => deleteAddress,
-    getToken: () => getToken,
-    handleCallback: () => handleCallback,
     isLoggedIn: () => isLoggedIn,
     login: () => login,
     logout: () => logout,
     mountAccount: () => mountAccount,
     order: () => order,
     orders: () => orders,
-    query: () => query,
     render: () => render,
     requestReturn: () => requestReturn,
     saveAddress: () => saveAddress,
@@ -28,432 +25,516 @@
     updateProfile: () => updateProfile
   });
 
-  // tether-core:config.js
-  var m = window.Tether.__core["config.js"];
-  var { DEFAULTS, cfg, configure, isConfigured, log, reportError, warn } = m;
+  // tether-core:config.ts
+  var m = window.Tether.__core["config.ts"];
+  var [cfg, isConfigured, log, MARKET_SOURCES, parseMarkets, reportError, warn] = m;
 
-  // tether-core:client.js
-  var m2 = window.Tether.__core["client.js"];
-  var { TetherError, endpoint, gql, request, unwrap, withContext } = m2;
+  // tether-core:client.ts
+  var m2 = window.Tether.__core["client.ts"];
+  var [endpoint, gql, orNull, shaped, TetherError] = m2;
 
-  // tether-core:dom.js
-  var m3 = window.Tether.__core["dom.js"];
-  var { attr, busy, cdnUrl, dataKey, emit, formatDate, formatMoney, formatPercent, get, has, hasTemplate, imageUrl, notifyLayoutChanged, parseJSONAttr, productUrl, qsa, readText, repeat, repeatKeyed, sameImage, scoped, sel, setImage, setSelected, setText, setTextTracked, show, toAttributes, watchImages } = m3;
+  // tether-core:dom.ts
+  var m3 = window.Tether.__core["dom.ts"];
+  var [ANALYTICS_EVENTS, attr, attributesFromJson, emit, formatDate, formatMoney, get, has, hasTemplate, isOwnEvent, parseJSONAttr, productUrl, qsa, repeat, sel, setImage, setText, show] = m3;
 
-  // tether-core:cart.js
-  var m4 = window.Tether.__core["cart.js"];
-  var { Cart, focusables, toLineInput } = m4;
+  // tether-core:cart.ts
+  var m4 = window.Tether.__core["cart.ts"];
+  var [Cart] = m4;
 
-  // tether-core:lazy.js
-  var m5 = window.Tether.__core["lazy.js"];
-  var { coreModules, loadPart } = m5;
+  // tether-core:lazy.ts
+  var m5 = window.Tether.__core["lazy.ts"];
+  var [loadPart] = m5;
 
-  // src/account.js
-  var KEY = () => `${cfg.prefix}:account:${cfg.domain}`;
-  var PENDING = () => `${cfg.prefix}:account-login:${cfg.domain}`;
-  var store = () => cfg.account?.remember ? window.localStorage : window.sessionStorage;
-  var b64url = (bytes) => btoa(String.fromCharCode(...new Uint8Array(bytes))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-  var random = () => b64url(crypto.getRandomValues(new Uint8Array(32)));
-  var sha256 = async (s) => b64url(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(s)));
-  var go = (url) => (cfg.account?.navigate || ((u) => window.location.assign(u)))(url);
-  var read = (s, k) => {
-    try {
-      return JSON.parse(s.getItem(k) || "null");
-    } catch {
-      return null;
-    }
-  };
-  var write = (s, k, v) => {
+  // server/src/shared/json.ts
+  function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  }
+  function field(value, key) {
+    return isRecord(value) ? value[key] : void 0;
+  }
+  function asList(value) {
+    return Array.isArray(value) ? value : [];
+  }
+  function textOrNull(value) {
+    return typeof value === "string" && value !== "" ? value : null;
+  }
+  var numberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+  var countOrZero = (value) => numberOrNull(value) ?? 0;
+  var listOf = (value, read) => asList(value).map((item) => read(item));
+  var nodesOf = (connection, read) => ({
+    nodes: listOf(field(connection, "nodes"), read)
+  });
+  var textList = (value) => listOf(value, textOrNull).filter((line) => line !== null);
+
+  // server/src/shared/error-message.ts
+  function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+
+  // src/storage.ts
+  function setStored(key, value, area = "localStorage") {
     try {
-      if (v) s.setItem(k, JSON.stringify(v));
-      else s.removeItem(k);
+      window[area].setItem(key, value);
     } catch {
     }
-  };
-  var discovery = null;
-  var session = null;
-  var refreshing = null;
-  var customerCache = null;
-  var server = () => cfg.account?.server ? new URL(String(cfg.account.server), window.location.href).href.replace(/\/$/, "") : "";
-  var HINT = () => `${cfg.prefix}:account-hint:${cfg.domain}`;
-  var serverState = null;
-  async function serverFetch(path, { method = "GET", body } = {}) {
-    const res = await fetch(`${server()}${path}`, {
-      method,
-      credentials: "include",
-      headers: method === "POST" ? { "Content-Type": "application/json", "X-Tether-Account": "1" } : {},
-      body: body ? JSON.stringify(body) : void 0
-    });
-    const data = await res.json().catch(() => ({}));
-    if (!res.ok && res.status !== 401) throw new TetherError(`Customer accounts: ${data.error || res.status}`, { status: res.status, userErrors: data.userErrors });
-    return data;
   }
-  async function serverMe() {
-    serverState || (serverState = await serverFetch("/me"));
+  function removeStored(key, area = "localStorage") {
     try {
-      if (serverState.loggedIn) window.localStorage.setItem(HINT(), "1");
-      else window.localStorage.removeItem(HINT());
+      window[area].removeItem(key);
     } catch {
     }
-    return serverState;
-  }
-  async function discover() {
-    if (discovery) return discovery;
-    const shop = cfg.account?.shopDomain || cfg.domain;
-    const get2 = (p) => fetch(`https://${shop}/.well-known/${p}`).then((r) => {
-      if (!r.ok) throw new TetherError(`Customer accounts: ${p} answered ${r.status}`, { status: r.status });
-      return r.json();
-    });
-    const [oidc, api] = await Promise.all([get2("openid-configuration"), get2("customer-account-api")]);
-    discovery = { ...oidc, graphql: api.graphql_api };
-    return discovery;
-  }
-  var callbackUrl = () => cfg.account?.callbackUrl || `${window.location.origin}${window.location.pathname}`;
-  function isLoggedIn() {
-    return server() ? Boolean(serverState?.loggedIn) : Boolean(session?.refresh || session?.access && session.expiresAt > Date.now());
-  }
-  async function login({ returnTo = window.location.href, locale } = {}) {
-    if (server()) {
-      const u2 = new URL(`${server()}/login`);
-      u2.searchParams.set("returnTo", returnTo);
-      const lang2 = locale || cfg.account.locale || (cfg.locale || "").split("-")[0];
-      if (lang2) u2.searchParams.set("locale", lang2);
-      if (cfg.country) u2.searchParams.set("country", String(cfg.country).toUpperCase());
-      go(u2.toString());
-      return;
+  }
+
+  // src/account-marks.ts
+  var hintKey = () => `${cfg.prefix}:account-hint:${cfg.domain}`;
+  var isLoginOutcome = (value) => value === "in" || value === "expired" || value === "error";
+
+  // server/src/shared/account-orders.ts
+  function moneyOrNull(value) {
+    const amount = textOrNull(field(value, "amount"));
+    const currencyCode = textOrNull(field(value, "currencyCode"));
+    return amount === null || currencyCode === null ? null : { amount, currencyCode };
+  }
+  function imageOrNull(value) {
+    const url = textOrNull(field(value, "url"));
+    return url === null ? null : { url, altText: textOrNull(field(value, "altText")) };
+  }
+  var toOrderLine = (value) => ({
+    title: textOrNull(field(value, "title")),
+    variantTitle: textOrNull(field(value, "variantTitle")),
+    quantity: countOrZero(field(value, "quantity")),
+    image: imageOrNull(field(value, "image"))
+  });
+  var toAccountOrder = (value, id) => ({
+    id,
+    name: textOrNull(field(value, "name")),
+    processedAt: textOrNull(field(value, "processedAt")),
+    financialStatus: textOrNull(field(value, "financialStatus")),
+    fulfillmentStatus: textOrNull(field(value, "fulfillmentStatus")),
+    statusPageUrl: textOrNull(field(value, "statusPageUrl")),
+    totalPrice: moneyOrNull(field(value, "totalPrice")),
+    lineItems: nodesOf(field(value, "lineItems"), toOrderLine)
+  });
+  function readOrders(value) {
+    const orders2 = [];
+    for (const item of asList(value)) {
+      const id = textOrNull(field(item, "id"));
+      if (id === null) return { kind: "missing-id" };
+      orders2.push(toAccountOrder(item, id));
     }
-    if (!cfg.account?.clientId) throw new TetherError("Customer accounts: set account.clientId", { code: "NOT_CONFIGURED" });
-    const d = await discover();
-    const state = random();
-    const nonce = random();
-    const verifier = random();
-    const redirect = callbackUrl();
-    write(window.sessionStorage, PENDING(), { state, nonce, verifier, redirect, returnTo, at: Date.now() });
-    const u = new URL(d.authorization_endpoint);
-    const p = {
-      client_id: cfg.account.clientId,
-      scope: "openid email customer-account-api:full",
-      response_type: "code",
-      redirect_uri: redirect,
-      state,
-      nonce,
-      code_challenge: await sha256(verifier),
-      code_challenge_method: "S256"
+    return { kind: "read", orders: orders2 };
+  }
+
+  // src/account/answers.ts
+  var unexpected = (what) => new TetherError(`Customer accounts: the answer has no ${what}`);
+  function toAccountCustomer(value) {
+    const customer2 = isRecord(value) ? value : {};
+    const id = textOrNull(customer2["id"]);
+    const email = textOrNull(customer2["email"]);
+    const address = customer2["address"];
+    return {
+      ...id === null ? {} : { id },
+      firstName: textOrNull(customer2["firstName"]),
+      lastName: textOrNull(customer2["lastName"]),
+      displayName: textOrNull(customer2["displayName"]),
+      emailAddress: email === null ? null : { emailAddress: email },
+      defaultAddress: Array.isArray(address) ? { formatted: textList(address) } : null
     };
-    const lang = locale || cfg.account.locale || (cfg.locale || "").split("-")[0];
-    if (lang) p.locale = lang;
-    if (cfg.country) p.region_country = String(cfg.country).toUpperCase();
-    Object.entries(p).forEach(([k, v]) => u.searchParams.set(k, v));
-    go(u.toString());
-  }
-  async function tokenRequest(params) {
-    const d = await discover();
-    const res = await fetch(cfg.account.tokenUrl || d.token_endpoint, { method: "POST", body: new URLSearchParams(params) });
-    const data = await res.json().catch(() => ({}));
-    if (!res.ok || !data.access_token) throw new TetherError(`Customer accounts: token ${res.status} ${data.error || ""}`.trim(), { status: res.status, code: res.status === 400 || res.status === 401 ? "SESSION_ENDED" : "TOKEN_FAILED" });
-    return data;
-  }
-  function decodeJwt(t) {
-    try {
-      return JSON.parse(atob(t.split(".")[1].replace(/-/g, "+").replace(/_/g, "/")));
-    } catch {
-      return null;
-    }
   }
-  function keep(data, previous = session) {
-    session = {
-      access: data.access_token,
-      expiresAt: Date.now() + Math.max(0, (Number(data.expires_in) || 3600) - 120) * 1e3,
-      refresh: data.refresh_token || previous?.refresh,
-      idToken: data.id_token || previous?.idToken
+  function toAccountOrders(value) {
+    const reading = readOrders(value);
+    if (reading.kind === "missing-id") throw unexpected("order id");
+    return reading.orders;
+  }
+  function toUserError(value) {
+    const message = textOrNull(field(value, "message"));
+    if (message === null) return null;
+    const fieldPath = field(value, "field");
+    return {
+      message,
+      field: Array.isArray(fieldPath) ? textList(fieldPath) : null,
+      code: textOrNull(field(value, "code"))
     };
-    write(store(), KEY(), session);
-  }
-  async function handleCallback() {
-    const q = new URLSearchParams(window.location.search);
-    const pending = read(window.sessionStorage, PENDING());
-    if (!pending || !q.has("code") && !q.has("error") || q.get("state") !== pending.state) return false;
-    write(window.sessionStorage, PENDING(), null);
-    const clean = new URL(window.location.href);
-    ["code", "state", "iss", "error", "error_description"].forEach((k) => clean.searchParams.delete(k));
-    window.history.replaceState(window.history.state, "", clean);
-    if (q.has("error")) {
-      emit("account-error", { error: q.get("error") });
-      return false;
-    }
-    if (Date.now() - pending.at > 10 * 6e4) throw new TetherError("Customer accounts: the login took too long, please try again");
-    const data = await tokenRequest({
-      grant_type: "authorization_code",
-      client_id: cfg.account.clientId,
-      redirect_uri: pending.redirect,
-      code: q.get("code"),
-      code_verifier: pending.verifier
-    });
-    const d = await discover();
-    const claims = decodeJwt(data.id_token || "");
-    const aud = [].concat(claims?.aud || []);
-    if (!claims || claims.nonce !== pending.nonce || claims.iss !== d.issuer || !aud.includes(cfg.account.clientId) || claims.exp * 1e3 < Date.now()) {
-      throw new TetherError("Customer accounts: the login answer did not check out (nonce/issuer/audience)");
+  }
+  var toUserErrors = (value) => listOf(value, toUserError).filter((error) => error !== null);
+
+  // src/account/server-client.ts
+  var known = null;
+  function serverBase() {
+    const server = cfg.account?.server;
+    if (!server) {
+      throw new TetherError("Customer accounts need the Worker: set account.server", { code: "NOT_CONFIGURED" });
     }
-    keep(data, null);
-    await linkCart();
-    emit("account-login", {});
-    const back = pending.returnTo && new URL(pending.returnTo, window.location.href);
-    if (back && back.origin === window.location.origin && back.href !== clean.href) go(back.href);
-    return true;
-  }
-  async function getToken() {
-    if (server()) return null;
-    if (!session) session = read(store(), KEY());
-    if (!session) return null;
-    if (session.access && session.expiresAt > Date.now()) return session.access;
-    if (!session.refresh) {
-      endSession();
-      return null;
+    return new URL(server, window.location.href).href.replace(/\/$/, "");
+  }
+  function setLoginHint(loggedIn) {
+    if (loggedIn) setStored(hintKey(), "1");
+    else removeStored(hintKey());
+  }
+  async function fetchFromWorker(url, init) {
+    try {
+      return await fetch(url, init);
+    } catch (error) {
+      throw new TetherError(`Network error: ${messageOf(error)}`, {
+        code: "NETWORK"
+      });
     }
-    refreshing || (refreshing = (async () => {
-      try {
-        keep(await tokenRequest({ grant_type: "refresh_token", client_id: cfg.account.clientId, refresh_token: session.refresh }));
-        await linkCart();
-      } catch (err) {
-        if (err.code === "SESSION_ENDED") endSession();
-        else throw err;
-      } finally {
-        refreshing = null;
-      }
-    })());
-    await refreshing;
-    return session?.access || null;
-  }
-  function endSession() {
-    session = null;
-    customerCache = null;
-    write(store(), KEY(), null);
-    Cart.customerAccessToken = null;
-  }
-  async function linkCart() {
-    Cart.customerAccessToken = session?.access || null;
-    if (Cart.id() && session?.access) {
-      await Cart.setBuyerIdentity({ customerAccessToken: session.access }, { create: false }).catch((err) => reportError(err, "account cart"));
+  }
+  async function readJsonObjectOrEmpty(response) {
+    let json;
+    try {
+      json = await response.json();
+    } catch {
+      return {};
     }
+    return isRecord(json) ? json : {};
   }
-  async function query(q, variables = {}) {
-    if (server()) throw new TetherError("Customer accounts in server mode only answer customer() and orders()", { code: "NOT_ALLOWED" });
-    const token = await getToken();
-    if (!token) throw new TetherError("Not logged in", { code: "NOT_LOGGED_IN" });
-    const d = await discover();
-    const run = (t) => fetch(d.graphql, { method: "POST", headers: { "Content-Type": "application/json", Authorization: t }, body: JSON.stringify({ query: q, variables }) });
-    let res = await run(token);
-    if (res.status === 401 && session?.refresh) {
-      session.expiresAt = 0;
-      res = await run(await getToken());
+  async function serverFetch(path, { method = "GET", body } = {}) {
+    const init = { method, credentials: "include" };
+    if (method === "POST") init.headers = { "Content-Type": "application/json", "X-Tether-Account": "1" };
+    if (body) init.body = JSON.stringify(body);
+    const response = await fetchFromWorker(`${serverBase()}${path}`, init);
+    if (response.status === 401) return { kind: "logged-out" };
+    const data = await readJsonObjectOrEmpty(response);
+    if (!response.ok) {
+      const reason = textOrNull(data["error"]) ?? String(response.status);
+      const userErrors = toUserErrors(data["userErrors"]);
+      throw new TetherError(`Customer accounts: ${reason}`, {
+        status: response.status,
+        ...userErrors.length > 0 && { userErrors },
+        // The Worker marks refused input (a 400, or a 404 for a contract that isn't the customer's) with `code`.
+        ...data["code"] === "INVALID" && { code: "INVALID" }
+      });
     }
-    const json = await res.json().catch(() => ({}));
-    if (!res.ok || json.errors?.length) throw new TetherError(json.errors?.map((e) => e.message).join(" | ") || `Customer accounts: ${res.status}`, { status: res.status });
-    return json.data;
+    return { kind: "answer", data };
   }
-  async function customer() {
-    if (server()) {
-      const me = await serverMe();
-      return me.loggedIn ? { ...me.customer, emailAddress: { emailAddress: me.customer.email }, defaultAddress: { formatted: me.customer.address } } : null;
+  async function serverLogin() {
+    if (!known) {
+      const answer = await serverFetch("/me");
+      known = answer.kind === "answer" && answer.data["loggedIn"] === true ? { loggedIn: true, customer: toAccountCustomer(answer.data["customer"]) } : { loggedIn: false };
     }
-    if (customerCache) return customerCache;
-    const data = await query(`query TetherCustomer{customer{id firstName lastName displayName emailAddress{emailAddress}defaultAddress{formatted}}}`);
-    customerCache = data.customer;
-    return customerCache;
-  }
-  async function orders({ first = 10 } = {}) {
-    if (server()) return (await serverFetch(`/orders?first=${first}`)).orders || [];
-    const data = await query(`query TetherOrders($first:Int!){customer{orders(first:$first,sortKey:PROCESSED_AT,reverse:true){nodes{id name processedAt financialStatus fulfillmentStatus statusPageUrl totalPrice{amount currencyCode}lineItems(first:20){nodes{title variantTitle quantity image{url altText}}}}}}}`, { first });
-    return data.customer?.orders?.nodes || [];
-  }
-  async function logout({ returnTo = cfg.account?.logoutUrl || `${window.location.origin}/` } = {}) {
-    if (server()) {
-      const r = await serverFetch("/logout", { method: "POST", body: { returnTo, cartId: Cart.id() } });
-      serverState = { loggedIn: false };
-      try {
-        window.localStorage.removeItem(HINT());
-      } catch {
+    setLoginHint(known.loggedIn);
+    return known;
+  }
+  var isServerLoggedIn = () => known?.loggedIn === true;
+  function forgetServerLogin() {
+    known = null;
+  }
+  function navigate(url) {
+    const replacement = cfg.account?.navigate;
+    if (replacement) replacement(url);
+    else window.location.assign(url);
+  }
+  var loginLanguage = (locale) => locale || cfg.account?.locale || (cfg.locale || "").split("-")[0] || "";
+  function serverLoginRedirect({ returnTo, locale }) {
+    const url = new URL(`${serverBase()}/login`);
+    url.searchParams.set("returnTo", returnTo);
+    const language = loginLanguage(locale);
+    if (language) url.searchParams.set("locale", language);
+    if (cfg.country) url.searchParams.set("country", cfg.country.toUpperCase());
+    navigate(url.toString());
+  }
+  async function serverCheckoutUrl() {
+    const cartId = Cart.id();
+    if (!(await serverLogin()).loggedIn || !cartId) return null;
+    const answer = await serverFetch("/cart", { method: "POST", body: { cartId } });
+    if (answer.kind === "logged-out") return null;
+    return textOrNull(answer.data["checkoutUrl"]);
+  }
+  async function serverLogout(returnTo) {
+    const answer = await serverFetch("/logout", { method: "POST", body: { returnTo, cartId: Cart.id() } });
+    known = null;
+    setLoginHint(false);
+    emit("account-logout", {});
+    const logoutUrl = answer.kind === "answer" ? textOrNull(answer.data["logoutUrl"]) : null;
+    if (!logoutUrl) return "stayed";
+    navigate(logoutUrl);
+    return "redirected";
+  }
+
+  // tether-core:shopify-values.ts
+  var m6 = window.Tether.__core["shopify-values.ts"];
+  var [isHttpsUrl] = m6;
+
+  // src/account/markup.ts
+  function showIn(root, name, conditions) {
+    qsa(root, sel(name)).forEach((el) => {
+      const key = get(el, name) ?? "";
+      if (Object.hasOwn(conditions, key)) show(el, conditions[key] === true);
+    });
+  }
+  var bindsIn = (row, name) => qsa(row, sel(name)).concat(row.matches(sel(name)) ? [row] : []);
+  var ownValue = (values, key) => Object.hasOwn(values, key) ? values[key] : void 0;
+
+  // src/account/order-lines.ts
+  var lineTexts = (line, returnable) => ({
+    title: line.title || line.name || "",
+    "variant-title": line.variantTitle || "",
+    quantity: String(line.quantity),
+    price: formatMoney(line.price),
+    total: formatMoney(line.totalPrice),
+    sku: line.sku || "",
+    returnable: returnable === null ? void 0 : String(returnable)
+  });
+  var isInput = (el) => el.tagName === "INPUT";
+  function fillReturnControls(row, line, returnable) {
+    showIn(row, "order-line-show", { returnable: returnable > 0 });
+    qsa(row, sel("return-quantity")).forEach((input) => {
+      if (!isInput(input)) return;
+      input.max = String(returnable);
+      input.min = "0";
+      if (!input.value) input.value = "0";
+      input.disabled = returnable < 1;
+    });
+    qsa(row, `select${sel("return-reason")}`).forEach((select) => {
+      if (select.dataset["tetherFilled"] === line.id) return;
+      select.dataset["tetherFilled"] = line.id;
+      (line.suggestedReturnReasonDefinitions?.nodes ?? []).forEach((reason) => {
+        select.appendChild(new Option(reason.name ?? "", reason.id));
+      });
+    });
+  }
+  function fillLines(box, lines, returns) {
+    repeat(box, lines, (row, line) => {
+      const id = line.id;
+      const returnable = returns && id ? returns.get(id) ?? 0 : null;
+      if (id) row.dataset["tetherLine"] = id;
+      const texts = lineTexts(line, returnable);
+      bindsIn(row, "order-line").forEach((el) => {
+        const key = get(el, "order-line") ?? "";
+        if (key === "image") {
+          if (line.image) setImage(el, line.image.url, line.image.altText || line.title || "");
+          return;
+        }
+        const text = ownValue(texts, key);
+        if (text !== void 0) setText(el, text);
+      });
+      if (id && returnable !== null) fillReturnControls(row, { ...line, id }, returnable);
+    });
+  }
+
+  // src/account/order-list.ts
+  var DEFAULT_ORDER_COUNT = 10;
+  var MAX_ORDER_COUNT = 50;
+  var isOrderCount = (value) => typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= MAX_ORDER_COUNT;
+  function listLimit(limit) {
+    const asked = Number.parseInt(limit || String(DEFAULT_ORDER_COUNT), 10) || DEFAULT_ORDER_COUNT;
+    return Math.min(Math.max(asked, 1), MAX_ORDER_COUNT);
+  }
+  var numericId = (gid) => gid.replace(/\?.*$/, "").replace(/^.*\//, "");
+  function orderUrl(order2) {
+    const template = cfg.account?.orderUrl;
+    if (template) return template.replaceAll("{id}", encodeURIComponent(numericId(order2.id)));
+    const statusPage = order2.statusPageUrl;
+    return statusPage !== null && isHttpsUrl(statusPage) ? statusPage : null;
+  }
+  var orderTexts = (order2) => ({
+    name: order2.name ?? "",
+    date: formatDate(order2.processedAt),
+    total: formatMoney(order2.totalPrice),
+    status: order2.financialStatus?.toLowerCase(),
+    fulfillment: order2.fulfillmentStatus?.toLowerCase(),
+    items: order2.lineItems.nodes.map((line) => `${String(line.quantity)}\xD7 ${line.title ?? ""}`).join(", ")
+  });
+  function fillOrder(node, order2) {
+    const lines = order2.lineItems.nodes;
+    const url = orderUrl(order2);
+    const texts = orderTexts(order2);
+    qsa(node, sel("order-bind")).forEach((el) => {
+      const key = get(el, "order-bind") ?? "";
+      if (key === "url") {
+        if (url) el.setAttribute("href", url);
+        return;
       }
-      emit("account-logout", {});
-      if (r.logoutUrl) go(r.logoutUrl);
-      else render(document);
-      return;
-    }
-    const idToken = session?.idToken || read(store(), KEY())?.idToken;
-    if (Cart.id()) await Cart.setBuyerIdentity({ customerAccessToken: null }, { create: false }).catch(() => {
+      if (key === "image") {
+        const image = lines.find((line) => line.image)?.image;
+        if (image) setImage(el, image.url, image.altText || lines[0]?.title || "");
+        return;
+      }
+      const text = ownValue(texts, key);
+      if (text !== void 0) setText(el, text);
     });
-    endSession();
-    emit("account-logout", {});
-    if (!idToken) {
-      render(document);
-      return;
-    }
-    const d = await discover();
-    const u = new URL(d.end_session_endpoint);
-    u.searchParams.set("id_token_hint", idToken);
-    u.searchParams.set("post_logout_redirect_uri", returnTo);
-    go(u.toString());
+    qsa(node, sel("order-lines")).forEach((box) => {
+      fillLines(box, lines, null);
+    });
+    if (get(node, "order-bind") === "url" && url) node.setAttribute("href", url);
   }
-  var https = (u) => {
-    try {
-      return new URL(u).protocol === "https:";
-    } catch {
-      return false;
-    }
-  };
-  var date = (s) => {
+  async function renderOrderList(root, loadOrders) {
+    const lists = qsa(root, sel("orders"));
+    const first = lists[0];
+    if (!first) return;
+    showIn(root, "show", { "orders-loading": true, "orders-empty": false });
+    const limit = listLimit(get(first, "limit"));
+    let orders2;
     try {
-      return new Date(s).toLocaleDateString(cfg.locale || void 0);
-    } catch {
-      return s;
+      orders2 = await loadOrders(limit);
+    } catch (error) {
+      reportError(error, "orders");
+      orders2 = null;
     }
-  };
-  async function render(root = document) {
-    const logged = server() ? Boolean((await serverMe().catch(() => ({ loggedIn: false }))).loggedIn) : isLoggedIn() || Boolean(await getToken().catch(() => null));
-    qsa(root, sel("show")).forEach((el) => {
-      const k = get(el, "show");
-      if (k === "logged-in") show(el, logged);
-      if (k === "logged-out") show(el, !logged);
+    showIn(root, "show", { "orders-loading": false, "orders-empty": orders2?.length === 0 });
+    lists.forEach((list) => {
+      repeat(list, orders2 ?? [], fillOrder);
     });
-    qsa(root, sel("account-link")).forEach((a) => {
-      const k = get(a, "account-link");
-      const u = k === "payment" && (cfg.account?.paymentUrl || cfg.account?.subscriptionsUrl) || k === "subscriptions" && cfg.account?.subscriptionsUrl;
-      a.setAttribute("href", u || `https://${cfg.domain}/account`);
+  }
+
+  // src/account.ts
+  var PAGE_ATTRIBUTES = ["order", "addresses", "subscriptions", "profile-form", "address-form"];
+  var isLoggedIn = isServerLoggedIn;
+  function login({
+    returnTo = window.location.href,
+    locale
+  } = {}) {
+    return new Promise((resolve) => {
+      serverLoginRedirect({ returnTo, locale });
+      resolve();
     });
-    if (!logged) return;
-    await bindCustomer(root);
-    await Promise.all([renderOrderList(root), PAGE_ATTRS.some((n) => qsa(root, sel(n)).length) ? pages().then((m6) => m6.renderPages(root)) : null]);
   }
-  async function renderOrderList(root) {
-    const lists = qsa(root, sel("orders"));
-    if (lists.length) {
-      const ordersShow = (loading, empty) => qsa(root, sel("show")).forEach((el) => {
-        const k = get(el, "show");
-        if (k === "orders-loading") show(el, loading);
-        if (k === "orders-empty") show(el, empty);
-      });
-      ordersShow(true, false);
-      let failed = false;
-      const list = await orders({ first: parseInt(get(lists[0], "limit") || "10", 10) }).catch((err) => {
-        reportError(err, "orders");
-        failed = true;
-        return [];
+  async function customer() {
+    const me = await serverLogin();
+    return me.loggedIn ? me.customer : null;
+  }
+  async function orders({ first = DEFAULT_ORDER_COUNT } = {}) {
+    if (!isOrderCount(first)) {
+      throw new TetherError(`Customer accounts: orders() takes first from 1 to ${String(MAX_ORDER_COUNT)}`, {
+        code: "INVALID"
       });
-      ordersShow(false, !failed && list.length === 0);
-      lists.forEach((c) => repeat(c, list, (node, o) => {
-        const items = o.lineItems?.nodes || [];
-        qsa(node, sel("order-bind")).forEach((el) => {
-          const k = get(el, "order-bind");
-          if (k === "url") {
-            const u = orderUrl(o);
-            if (u) el.setAttribute("href", u);
-            return;
-          }
-          if (k === "image") {
-            const im = items.find((l) => l.image)?.image;
-            if (im) setImage(el, im.url, im.altText || items[0]?.title || "");
-            return;
-          }
-          const v = { name: o.name, date: date(o.processedAt), total: formatMoney(o.totalPrice), status: o.financialStatus?.toLowerCase(), fulfillment: o.fulfillmentStatus?.toLowerCase(), items: items.map((l) => `${l.quantity}\xD7 ${l.title}`).join(", ") }[k];
-          if (v != null) setText(el, v);
-        });
-        qsa(node, sel("order-lines")).forEach((box) => fillLines(box, items));
-        if (get(node, "order-bind") === "url" && orderUrl(o)) node.setAttribute("href", orderUrl(o));
-      }));
     }
+    const answer = await serverFetch(`/orders?${new URLSearchParams({ first: String(first) }).toString()}`);
+    return answer.kind === "logged-out" ? [] : toAccountOrders(answer.data["orders"]);
   }
-  var nid = (g) => String(g || "").split("/").pop().split("?")[0];
-  function orderUrl(o) {
-    const t = cfg.account?.orderUrl;
-    if (t) return String(t).replace("{id}", encodeURIComponent(nid(o.id)));
-    return https(o.statusPageUrl) ? o.statusPageUrl : null;
-  }
-  function fillLines(box, items) {
-    repeat(box, items, (row, l) => {
-      qsa(row, sel("order-line")).concat(row.matches(sel("order-line")) ? [row] : []).forEach((el) => {
-        const k = get(el, "order-line");
-        if (k === "image") {
-          if (l.image) setImage(el, l.image.url, l.image.altText || l.title);
-          return;
-        }
-        const v = { title: l.title, "variant-title": l.variantTitle || "", quantity: String(l.quantity) }[k];
-        if (v != null) setText(el, v);
-      });
+  async function logout({
+    returnTo = cfg.account?.logoutUrl || `${window.location.origin}/`
+  } = {}) {
+    if (await serverLogout(returnTo) === "stayed") await render(document);
+  }
+  async function loginState() {
+    try {
+      return (await serverLogin()).loggedIn ? { kind: "logged-in" } : { kind: "logged-out" };
+    } catch (error) {
+      return { kind: "unknown", error };
+    }
+  }
+  var usesPages = (root) => PAGE_ATTRIBUTES.some((name) => qsa(root, sel(name)).length > 0);
+  function linkShopifyPages(root) {
+    qsa(root, sel("account-link")).forEach((link) => {
+      link.setAttribute("href", shopifyPageUrl(get(link, "account-link")));
     });
   }
-  var PAGE_ATTRS = ["order", "addresses", "subscriptions", "profile-form", "address-form"];
-  var pagesPart = null;
+  function shopifyPageUrl(page) {
+    const account = cfg.account;
+    const fallback = `https://${cfg.domain}/account`;
+    if (page === "payment") return account?.paymentUrl || account?.subscriptionsUrl || fallback;
+    if (page === "subscriptions") return account?.subscriptionsUrl || fallback;
+    return fallback;
+  }
+  async function render(root = document) {
+    const state = await loginState();
+    if (state.kind === "unknown") reportError(state.error, "account");
+    const loggedIn = state.kind === "logged-in";
+    qsa(root, sel("show")).forEach((el) => {
+      const condition = get(el, "show");
+      if (condition === "logged-in") show(el, loggedIn);
+      if (condition === "logged-out") show(el, !loggedIn);
+    });
+    linkShopifyPages(root);
+    if (state.kind === "unknown" && usesPages(root)) {
+      (await pages()).showUnavailable(root);
+      return;
+    }
+    if (!loggedIn) return;
+    await bindCustomer(root);
+    await Promise.all([
+      renderOrderList(root, (first) => orders({ first })),
+      usesPages(root) ? pages().then((part) => part.renderPages(root)) : null
+    ]);
+  }
   async function bindCustomer(root) {
     const binds = qsa(root, sel("account-bind"));
     if (!binds.length) return;
-    const c = await customer().catch((err) => {
-      reportError(err, "account");
-      return null;
-    });
+    let profile;
+    try {
+      profile = await customer();
+    } catch (error) {
+      reportError(error, "account");
+      return;
+    }
+    if (!profile) return;
+    const texts = {
+      "first-name": profile.firstName,
+      "last-name": profile.lastName,
+      name: profile.displayName,
+      email: profile.emailAddress?.emailAddress,
+      address: profile.defaultAddress?.formatted.join(", ")
+    };
     binds.forEach((el) => {
-      const v = { "first-name": c?.firstName, "last-name": c?.lastName, name: c?.displayName, email: c?.emailAddress?.emailAddress, address: c?.defaultAddress?.formatted?.join(", ") }[get(el, "account-bind")];
-      if (v != null) setText(el, v);
+      const text = ownValue(texts, get(el, "account-bind") ?? "");
+      if (text != null) setText(el, text);
     });
   }
+  var pagesPart = null;
   function pages() {
-    pagesPart || (pagesPart = loadPart("account-pages").then((m6) => {
-      m6.setup({ server, serverFetch, query, customer, bindCustomer, reset: () => {
-        customerCache = null;
-        serverState = null;
-      } });
-      return m6;
+    pagesPart ?? (pagesPart = loadPart("account-pages").then((part) => {
+      part.setup({ serverFetch, customer, bindCustomer, reset: forgetServerLogin });
+      return part;
     }));
     return pagesPart;
   }
-  var viaPages = (name) => (...a) => pages().then((m6) => m6[name](...a));
-  var order = viaPages("order");
-  var updateProfile = viaPages("updateProfile");
-  var addresses = viaPages("addresses");
-  var saveAddress = viaPages("saveAddress");
-  var deleteAddress = viaPages("deleteAddress");
-  var subscriptions = viaPages("subscriptions");
-  var subscriptionAction = viaPages("subscriptionAction");
-  var requestReturn = viaPages("requestReturn");
-  var bound = false;
-  async function mountAccount(root = document) {
-    if (!bound) {
-      bound = true;
-      document.addEventListener("click", (e) => {
-        const t = e.target;
-        if (t.closest?.(sel("account-login"))) {
-          e.preventDefault();
-          login().catch((err) => reportError(err, "login"));
-        } else if (t.closest?.(sel("account-logout"))) {
-          e.preventDefault();
-          logout().catch((err) => reportError(err, "logout"));
-        }
+  var order = (id) => pages().then((part) => part.order(id));
+  var updateProfile = (fields) => pages().then((part) => part.updateProfile(fields));
+  var addresses = () => pages().then((part) => part.addresses());
+  var saveAddress = (address, options) => pages().then((part) => part.saveAddress(address, options));
+  var deleteAddress = (id) => pages().then((part) => part.deleteAddress(id));
+  var subscriptions = () => pages().then((part) => part.subscriptions());
+  var subscriptionAction = (id, action) => pages().then((part) => part.subscriptionAction(id, action));
+  var requestReturn = (orderId, lines) => pages().then((part) => part.requestReturn(orderId, lines));
+  function onClick(event) {
+    const target = event.target;
+    if (!(target instanceof window.Element)) return;
+    if (target.closest(sel("account-login"))) {
+      event.preventDefault();
+      login().catch((error) => {
+        reportError(error, "login");
       });
-      if (server()) {
-        const u = new URL(window.location.href);
-        if (u.searchParams.get("account")) {
-          u.searchParams.delete("account");
-          window.history.replaceState(window.history.state, "", u);
-          emit("account-login", {});
-        }
-        Cart.beforeCheckout = async () => {
-          if (!(await serverMe()).loggedIn || !Cart.id()) return null;
-          const r = await serverFetch("/cart", { method: "POST", body: { cartId: Cart.id() } }).catch(() => null);
-          return r?.checkoutUrl ? `${r.checkoutUrl}${r.checkoutUrl.includes("?") ? "&" : "?"}logged_in=true` : null;
-        };
-      } else {
-        try {
-          await handleCallback();
-        } catch (err) {
-          reportError(err, "login");
-        }
-        if (!Cart.customerAccessToken && await getToken().catch(() => null)) Cart.customerAccessToken = session.access;
-      }
-      log("account", isLoggedIn() ? "logged in" : "logged out");
+    } else if (target.closest(sel("account-logout"))) {
+      event.preventDefault();
+      logout().catch((error) => {
+        reportError(error, "logout");
+      });
+    }
+  }
+  function finishServerLogin() {
+    const url = new URL(window.location.href);
+    const outcome = url.searchParams.get("account");
+    if (!isLoginOutcome(outcome)) return;
+    url.searchParams.delete("account");
+    window.history.replaceState(window.history.state, "", url);
+    switch (outcome) {
+      case "in":
+        emit("account-login", {});
+        break;
+      case "expired":
+      case "error":
+        emit("account-error", { error: outcome });
+        break;
+    }
+  }
+  var started = false;
+  async function mountAccount(root = document) {
+    if (started) {
+      await render(root);
+      return;
     }
+    started = true;
+    document.addEventListener("click", onClick);
+    finishServerLogin();
+    Cart.setCheckoutResolver(serverCheckoutUrl);
     await render(root);
+    log("account", isLoggedIn() ? "logged in" : "logged out");
   }
 
-  // src/parts/account.js
-  window.Tether.__parts.account = account_exports;
+  // src/parts/account.ts
+  var { Tether } = window;
+  if (!Tether) throw new Error("tether.account.js runs after the Tether script, which loads it");
+  Tether.__parts.account = account_exports;
 })();