@misiki/gocommerce-connector 0.2.0 → 0.3.0

package/dist/services/index.js

@@ -165,7 +165,7 @@ function storedCartId() {
   if (!v || v === "undefined" || v === "null") return null;
   return v;
 }
-var rememberCartId = (id) => writeLocal("cart_id", id);
+var rememberCartId = (id2) => writeLocal("cart_id", id2);
 var extrasKey = (cartId) => `gocommerce_cart_${cartId}`;
 var cartExtras = (cartId) => readJSON(extrasKey(cartId)) ?? {};
 function saveCartExtras(cartId, patch) {
@@ -233,7 +233,8 @@ var BaseService = class _BaseService {
    * as what it is rather than as a JSON parse error three frames away.
    */
   async engine(path, req = {}) {
-    const url = this.engineURL(path, req.query);
+    const lang = (req.method ?? "GET") === "GET" ? this.creds.language : void 0;
+    const url = this.engineURL(path, lang ? { lang, ...req.query } : req.query);
     const headers = { Accept: "application/json", ...req.headers };
     if (req.body !== void 0) headers["Content-Type"] = "application/json";
     if (this.creds.store) headers["X-Store"] = this.creds.store;
@@ -456,6 +457,16 @@ function toVariant(v, p, optionless) {
     metadata: v.metadata ?? null
   };
 }
+function attributesOf(p) {
+  const answers = p.metadata?.category;
+  if (!answers || typeof answers !== "object" || Array.isArray(answers)) return [];
+  return Object.entries(answers).flatMap(([handle, raw]) => {
+    const values = (Array.isArray(raw) ? raw : [raw]).map((v) => String(v ?? "").trim()).filter(Boolean);
+    if (!values.length) return [];
+    const name = handle.replace(/[-_]+/g, " ").replace(/^./, (c) => c.toUpperCase());
+    return [{ name, value: values.join(", "), handle }];
+  });
+}
 function toProduct(p, extra = {}) {
   const live = liveVariants(p);
   const lead = live[0] ?? arr(p.variants)[0];
@@ -521,7 +532,7 @@ function toProduct(p, extra = {}) {
     rating: null,
     ratingCount: 0,
     reviewCount: 0,
-    attributes: [],
+    attributes: attributesOf(p),
     metadata: p.metadata ?? null,
     createdAt: p.created_at,
     updatedAt: p.updated_at
@@ -1078,8 +1089,11 @@ var CatalogService = class extends BaseService {
         sorted
       };
     }
+    const attr = Object.entries(q.attributes ?? {}).flatMap(
+      ([handle, values]) => values.filter(Boolean).map((v) => `${handle}:${v}`)
+    );
     const env = await this.engine("/api/products", {
-      query: { q: search, page, limit, channel: this.creds.channel }
+      query: { q: search, page, limit, channel: this.creds.channel, attr }
     });
     return { ...toPage(env, (p) => toProduct(p)), categoryHierarchy: hierarchy, sorted };
   }
@@ -1214,6 +1228,16 @@ var num = (v) => {
   const n = Number(v);
   return Number.isFinite(n) ? n : void 0;
 };
+function attributesFrom(p) {
+  const out = {};
+  for (const [key, value] of p) {
+    if (!key.startsWith("attributes.")) continue;
+    const handle = key.slice("attributes.".length);
+    const values = value.split(",").map((v) => decodeURIComponent(v).trim()).filter(Boolean);
+    if (handle && values.length) out[handle] = [...out[handle] ?? [], ...values];
+  }
+  return Object.keys(out).length ? out : void 0;
+}
 var SearchService = class extends CatalogService {
   emptyResult() {
     return {
@@ -1235,7 +1259,8 @@ var SearchService = class extends CatalogService {
         sort: p.get("sort") ?? void 0,
         category: slug || p.get("categories")?.split(",")[0] || void 0,
         priceFrom: num(p.get("priceFrom")) ?? num(from ?? null),
-        priceTo: num(p.get("priceTo")) ?? num(to ?? null)
+        priceTo: num(p.get("priceTo")) ?? num(to ?? null),
+        attributes: attributesFrom(p)
       });
       return {
         data: res.data,
@@ -1367,10 +1392,10 @@ var REMOVE = -9999999;
 var CartService = class extends BaseService {
   facts = new StoreFacts(this._fetch);
   async getCartByCartId(cartId) {
-    const id = clean(cartId);
-    if (!id) return emptyCart(await this.currency());
+    const id2 = clean(cartId);
+    if (!id2) return emptyCart(await this.currency());
     try {
-      return await this.present(await this.data(`/api/carts/${encodeURIComponent(id)}`));
+      return await this.present(await this.data(`/api/carts/${encodeURIComponent(id2)}`));
     } catch (err) {
       if (err instanceof GoCommerceError && err.status === 404) return emptyCart(await this.currency());
       throw err;
@@ -1385,9 +1410,9 @@ var CartService = class extends BaseService {
    * to clear the bag on the success page.
    */
   async refereshCart() {
-    const id = storedCartId();
-    const cart = await this.getCartByCartId(id);
-    if (id && cart.status === "converted") forgetCartExtras(id);
+    const id2 = storedCartId();
+    const cart = await this.getCartByCartId(id2);
+    if (id2 && cart.status === "converted") forgetCartExtras(id2);
     return cart;
   }
   /**
@@ -1400,21 +1425,21 @@ var CartService = class extends BaseService {
     qty = 1,
     variantId
   }) {
-    let id = clean(cartId) ?? storedCartId();
-    if (lineId && id) {
-      const cart = await this.data(`/api/carts/${encodeURIComponent(id)}`);
+    let id2 = clean(cartId) ?? storedCartId();
+    if (lineId && id2) {
+      const cart = await this.data(`/api/carts/${encodeURIComponent(id2)}`);
       const line = (cart.line_items ?? []).find((l) => String(l.id) === String(lineId));
       if (line) {
         const next = qty === REMOVE ? 0 : line.quantity + Number(qty);
-        return this.setQuantity(id, line.id, next);
+        return this.setQuantity(id2, line.id, next);
       }
     }
-    if (qty === REMOVE || Number(qty) <= 0) return this.getCartByCartId(id);
+    if (qty === REMOVE || Number(qty) <= 0) return this.getCartByCartId(id2);
     if (!variantId) throw new GoCommerceError("Please choose an option before adding this to your bag.", 400);
-    if (!id) id = await this.open();
+    if (!id2) id2 = await this.open();
     try {
       return await this.present(
-        await this.data(`/api/carts/${encodeURIComponent(id)}/line-items`, {
+        await this.data(`/api/carts/${encodeURIComponent(id2)}/line-items`, {
           method: "POST",
           body: { variant_id: Number(variantId), quantity: Number(qty) }
         })
@@ -1438,15 +1463,15 @@ var CartService = class extends BaseService {
     lineId,
     qty
   }) {
-    const id = clean(cartId) ?? storedCartId();
-    if (!id) return emptyCart(await this.currency());
-    return this.setQuantity(id, lineId, Number(qty));
+    const id2 = clean(cartId) ?? storedCartId();
+    if (!id2) return emptyCart(await this.currency());
+    return this.setQuantity(id2, lineId, Number(qty));
   }
   async removeCart({ cartId, lineId }) {
-    const id = clean(cartId) ?? storedCartId();
-    if (!id) return emptyCart(await this.currency());
+    const id2 = clean(cartId) ?? storedCartId();
+    if (!id2) return emptyCart(await this.currency());
     return this.present(
-      await this.data(`/api/carts/${encodeURIComponent(id)}/line-items/${encodeURIComponent(String(lineId))}`, {
+      await this.data(`/api/carts/${encodeURIComponent(id2)}/line-items/${encodeURIComponent(String(lineId))}`, {
         method: "DELETE"
       })
     );
@@ -1457,8 +1482,8 @@ var CartService = class extends BaseService {
    * and the rest is kept for the checkout request.
    */
   async updateCart2(args) {
-    const id = clean(args.cartId) ?? storedCartId();
-    if (!id) return emptyCart(await this.currency());
+    const id2 = clean(args.cartId) ?? storedCartId();
+    if (!id2) return emptyCart(await this.currency());
     const patch = {};
     if (args.phone !== void 0) patch.phone = args.phone || void 0;
     if (args.shippingAddress !== void 0) {
@@ -1468,20 +1493,20 @@ var CartService = class extends BaseService {
     if (args.billingAddress !== void 0 || args.isBillingAddressSameAsShipping) {
       patch.billingAddress = args.isBillingAddressSameAsShipping ? null : args.billingAddress ?? null;
     }
-    const before = cartExtras(id);
+    const before = cartExtras(id2);
     const country = (a) => String(a?.countryCode || a?.country || "").toUpperCase();
     if (args.shippingAddress !== void 0 && country(args.shippingAddress) !== country(before.shippingAddress)) {
       patch.shippingRateId = null;
       patch.shippingRate = null;
     }
-    saveCartExtras(id, patch);
+    saveCartExtras(id2, patch);
     const email = args.email ?? (args.shippingAddress?.email ? String(args.shippingAddress.email) : void 0);
     if (email !== void 0) {
       return this.present(
-        await this.data(`/api/carts/${encodeURIComponent(id)}/email`, { method: "PUT", body: { email } })
+        await this.data(`/api/carts/${encodeURIComponent(id2)}/email`, { method: "PUT", body: { email } })
       );
     }
-    return this.getCartByCartId(id);
+    return this.getCartByCartId(id2);
   }
   /**
    * A discount code. The engine prices it against the basket now and decides
@@ -1489,34 +1514,34 @@ var CartService = class extends BaseService {
    * because the cart itself does not carry the code.
    */
   async applyCoupon({ cartId, couponCode }) {
-    const id = clean(cartId) ?? storedCartId();
-    if (!id) throw new GoCommerceError("Add something to your bag before applying a code.", 400);
-    const cart = await this.data(`/api/carts/${encodeURIComponent(id)}`);
-    const discount = await this.data(`/api/carts/${encodeURIComponent(id)}/discount`, {
+    const id2 = clean(cartId) ?? storedCartId();
+    if (!id2) throw new GoCommerceError("Add something to your bag before applying a code.", 400);
+    const cart = await this.data(`/api/carts/${encodeURIComponent(id2)}`);
+    const discount = await this.data(`/api/carts/${encodeURIComponent(id2)}/discount`, {
       method: "PUT",
       body: { code: String(couponCode ?? "").trim(), ...cart.email ? { email: cart.email } : {} }
     });
-    saveCartExtras(id, { discount: { ...discount, code: discount.code || String(couponCode).trim() } });
+    saveCartExtras(id2, { discount: { ...discount, code: discount.code || String(couponCode).trim() } });
     return this.present(cart);
   }
   async removeCoupon(cartId) {
-    const id = clean(cartId) ?? storedCartId();
-    if (!id) return emptyCart(await this.currency());
-    await this.engine(`/api/carts/${encodeURIComponent(id)}/discount`, { method: "DELETE" });
-    saveCartExtras(id, { discount: null });
-    return this.getCartByCartId(id);
+    const id2 = clean(cartId) ?? storedCartId();
+    if (!id2) return emptyCart(await this.currency());
+    await this.engine(`/api/carts/${encodeURIComponent(id2)}/discount`, { method: "DELETE" });
+    saveCartExtras(id2, { discount: null });
+    return this.getCartByCartId(id2);
   }
   /** The delivery option the shopper picked, priced from the engine's own quote. */
   async updateShippingRate({ cartId, shippingRateId }) {
-    const id = clean(cartId) ?? storedCartId();
-    if (!id) return emptyCart(await this.currency());
-    const ship = cartExtras(id).shippingAddress;
+    const id2 = clean(cartId) ?? storedCartId();
+    if (!id2) return emptyCart(await this.currency());
+    const ship = cartExtras(id2).shippingAddress;
     const country = String(ship?.countryCode || ship?.country || "").toUpperCase();
     if (!country) throw new GoCommerceError("Add a delivery address first.", 400);
-    const quote2 = await this.data("/api/checkout/rates", { query: { cart: id, country, state: ship?.state ? String(ship.state) : void 0 } });
+    const quote2 = await this.data("/api/checkout/rates", { query: { cart: id2, country, state: ship?.state ? String(ship.state) : void 0 } });
     const rate = (quote2.rates ?? []).find((r) => String(r.rate_id) === String(shippingRateId));
     if (!rate) throw new GoCommerceError("That delivery option is not available for this address any more.", 409);
-    saveCartExtras(id, {
+    saveCartExtras(id2, {
       shippingRateId: String(rate.rate_id),
       shippingRate: {
         id: String(rate.rate_id),
@@ -1525,7 +1550,7 @@ var CartService = class extends BaseService {
         currency: rate.price.currency
       }
     });
-    return this.getCartByCartId(id);
+    return this.getCartByCartId(id2);
   }
   /** The payment method is chosen at checkout, by which checkout route is called. */
   async updateCartPaymentMethod({ cartId }) {
@@ -1571,25 +1596,25 @@ var CartService = class extends BaseService {
       return { slug: p.slug, thumbnail: v?.image?.url ?? p.image_url ?? null };
     });
   }
-  productFor(id) {
+  productFor(id2) {
     return remember(
-      `${this.engineBase()}|product|${id}`,
-      () => this.data(`/api/products/${id}`).catch(() => null)
+      `${this.engineBase()}|product|${id2}`,
+      () => this.data(`/api/products/${id2}`).catch(() => null)
     );
   }
 };
-var clean = (id) => id && id !== "undefined" && id !== "null" ? id : null;
+var clean = (id2) => id2 && id2 !== "undefined" && id2 !== "null" ? id2 : null;
 var cartService = new CartService();
 
 // src/services/checkout-service.ts
 var CheckoutService = class extends BaseService {
   /** Delivery options for the address on the cart: `{ data: [{ id, name, base_rate }] }`. */
   async getShippingRates({ cartId } = {}) {
-    const id = cartId || storedCartId();
-    const ship = id ? cartExtras(id).shippingAddress : null;
+    const id2 = cartId || storedCartId();
+    const ship = id2 ? cartExtras(id2).shippingAddress : null;
     const country = String(ship?.countryCode || ship?.country || "").toUpperCase();
-    if (!id || !country) return { data: [] };
-    const quote2 = await this.data("/api/checkout/rates", { query: { cart: id, country, state: ship?.state ? String(ship.state) : void 0 } });
+    if (!id2 || !country) return { data: [] };
+    const quote2 = await this.data("/api/checkout/rates", { query: { cart: id2, country, state: ship?.state ? String(ship.state) : void 0 } });
     return {
       data: (quote2.rates ?? []).map((r) => ({
         id: String(r.rate_id),
@@ -1643,10 +1668,11 @@ var CheckoutService = class extends BaseService {
     if (!order) throw new GoCommerceError("That payment does not belong to an order placed from this browser.", 404);
     return { order_no: order.number, status: "processing" };
   }
-  // The family's other gateways. GoCommerce's Stripe is a Payment Element
-  // (a client secret, not a hosted page), and PayPal, Cashfree, PhonePe and
-  // Affirm are not engine gateways at all; paymentMethodService never lists
-  // them, so these are reached only by a storefront that hard-codes one.
+  // The family's other gateway flows. GoCommerce's Stripe is a Payment
+  // Element (a client secret, not a hosted page) — `checkout('stripe')` returns
+  // that secret for a storefront that mounts the element. Cashfree, PhonePe and
+  // Affirm are not engine gateways at all. paymentMethodService never offers
+  // these codes, so they are reached only by a storefront that hard-codes one.
   async checkoutStripe() {
     throw unsupported(
       "checkoutStripe",
@@ -1656,11 +1682,34 @@ var CheckoutService = class extends BaseService {
   async checkoutStripeCapture() {
     throw unsupported("checkoutStripeCapture", "Stripe confirms payments to the engine by webhook");
   }
-  async checkoutPaypal() {
-    throw unsupported("checkoutPaypal", "the engine has no PayPal gateway");
+  /**
+   * The storefront's generic redirect flow, which it reaches through the code
+   * `PAYPAL`. The engine has no PayPal gateway; paymentMethodService puts the
+   * store's first hosted-page gateway — Adyen, Paddle, Lemon Squeezy, Creem,
+   * Hyperswitch or RevenueCat — under that code, with its own name and a
+   * neutral icon, because this is the one storefront flow that sends a shopper
+   * to a URL and back. The shopper returns to the success page; the gateway's
+   * webhook tells the engine the order is paid.
+   */
+  async checkoutPaypal({ cartId, origin } = {}) {
+    const gateway = await this.redirectGateway();
+    if (!gateway) throw unsupported("checkoutPaypal", "this store has no hosted-page payment gateway switched on");
+    const id2 = cartId || storedCartId() || "";
+    const back = origin ? `${origin.replace(/\/+$/, "")}/checkout/success?cart_id=${encodeURIComponent(id2)}` : void 0;
+    const result = await this.place(gateway, id2, back ? { return_url: back } : {});
+    const url = result.payment.client_data?.url;
+    if (!url) throw new GoCommerceError("The payment page did not open. Please try again.", 502);
+    return { redirect_url: url, order_no: result.order.number };
   }
-  async capturePaypalPayment() {
-    throw unsupported("capturePaypalPayment", "the engine has no PayPal gateway");
+  /**
+   * Nothing to capture: a hosted-page gateway confirms the payment to the
+   * engine by webhook. Answering, rather than throwing, sends the storefront's
+   * process page on to the success page instead of the failure page.
+   */
+  async capturePaypalPayment({
+    order_no
+  } = {}) {
+    return { order_no: order_no ?? null, status: "processing" };
   }
   async checkoutCashfree() {
     throw unsupported("checkoutCashfree", "the engine has no Cashfree gateway");
@@ -1683,6 +1732,57 @@ var CheckoutService = class extends BaseService {
   async checkoutPOS() {
     throw unsupported("checkoutPOS", "point-of-sale orders are placed from the admin panel");
   }
+  /**
+   * Any payment method the engine has switched on, by its engine code —
+   * `cod`, `stripe`, `razorpay`, `adyen`, `paddle`, `helcim`… For a storefront
+   * that drives the payment itself: the answer says what to do next.
+   *
+   * - `kind: 'none'` — nothing to pay now (cash on delivery).
+   * - `kind: 'client_action'` — mount the gateway's own widget with
+   *   `clientData`: Stripe's Payment Element takes `clientSecret`, Razorpay's
+   *   modal `razorpay_order_id` and `key_id`, Helcim's `checkout_token`.
+   * - `kind: 'redirect'` — send the shopper to `redirectUrl`; `returnUrl` is
+   *   where the gateway brings them back.
+   *
+   * Either way the gateway's webhook tells the engine when the money arrives;
+   * read `orderService.getOrder(orderNo).paymentStatus` to see it.
+   */
+  async checkout(code, {
+    cartId,
+    returnUrl,
+    paymentData,
+    metadata
+  } = {}) {
+    const result = await this.place(String(code).toLowerCase(), cartId, {
+      ...returnUrl ? { return_url: returnUrl } : {},
+      ...paymentData ? { payment_data: paymentData } : {},
+      ...metadata ? { metadata } : {}
+    });
+    const data = result.payment.client_data ?? {};
+    return {
+      orderNo: result.order.number,
+      order: toOrder(result.order),
+      payment: {
+        kind: result.payment.kind,
+        provider: result.payment.provider,
+        reference: result.payment.reference ?? null,
+        clientSecret: data.client_secret ?? null,
+        redirectUrl: data.url ?? null,
+        clientData: data
+      }
+    };
+  }
+  /** Every payment method the engine has switched on, by engine code and name — drivable here or not. */
+  async listMethods() {
+    const options = await this.data(
+      "/api/checkout"
+    );
+    return { methods: options.methods ?? [], currency: options.currency };
+  }
+  async redirectGateway() {
+    const { methods } = await this.listMethods();
+    return methods.find((m) => REDIRECT_GATEWAYS.has(m.code))?.code;
+  }
   /**
    * One checkout attempt.
    *
@@ -1693,27 +1793,28 @@ var CheckoutService = class extends BaseService {
    * request — a different address, a different method — gets a new key, since
    * the engine refuses a key replayed with a different body.
    */
-  async place(code, cartId) {
-    const id = cartId || storedCartId();
-    if (!id) throw new GoCommerceError("Your bag is empty.", 400);
-    const extras = cartExtras(id);
+  async place(code, cartId, extra = {}) {
+    const id2 = cartId || storedCartId();
+    if (!id2) throw new GoCommerceError("Your bag is empty.", 400);
+    const extras = cartExtras(id2);
     const ship = extras.shippingAddress;
     if (!ship) throw new GoCommerceError("Add a delivery address first.", 400);
-    const cart = await this.data(`/api/carts/${encodeURIComponent(id)}`);
+    const cart = await this.data(`/api/carts/${encodeURIComponent(id2)}`);
     const email = cart.email || (ship.email ? String(ship.email) : "");
     if (!email) throw new GoCommerceError("Add an email address so we can send your receipt.", 400);
     const address = toEngineAddress(ship);
     const body = {
-      cart_id: id,
+      cart_id: id2,
       email,
       ...extras.phone || address.phone ? { phone: String(extras.phone || address.phone) } : {},
       ...address.name ? { name: address.name } : {},
       address,
-      ...extras.shippingRateId ? { shipping_rate_id: Number(extras.shippingRateId) } : {}
+      ...extras.shippingRateId ? { shipping_rate_id: Number(extras.shippingRateId) } : {},
+      ...extra
     };
     const serialised = JSON.stringify(body);
     const key = extras.attempt?.body === `${code}:${serialised}` ? extras.attempt.key : newKey();
-    saveCartExtras(id, { attempt: { key, body: `${code}:${serialised}` } });
+    saveCartExtras(id2, { attempt: { key, body: `${code}:${serialised}` } });
     const result = await this.data(`/api/checkout/${encodeURIComponent(code)}`, {
       method: "POST",
       body,
@@ -1723,7 +1824,7 @@ var CheckoutService = class extends BaseService {
       rememberOrder({
         number: result.order.number,
         token: result.order.access_token,
-        cartId: id,
+        cartId: id2,
         reference: result.payment.client_data?.razorpay_order_id ?? result.payment.reference
       });
       if (sessionToken()) {
@@ -1734,10 +1835,11 @@ var CheckoutService = class extends BaseService {
         }).catch(() => void 0);
       }
     }
-    saveCartExtras(id, { attempt: null });
+    saveCartExtras(id2, { attempt: null });
     return result;
   }
 };
+var REDIRECT_GATEWAYS = /* @__PURE__ */ new Set(["adyen", "paddle", "lemonsqueezy", "creem", "hyperswitch", "revenuecat"]);
 var unsupported = (method, why) => new NotSupportedError("CheckoutService", method, why);
 function newKey() {
   const c = globalThis.crypto;
@@ -1757,23 +1859,25 @@ var PaymentMethodService = class extends BaseService {
   async list(_args = {}) {
     const options = await this.facts.checkoutOptions();
     const methods = options.methods ?? [];
+    const redirect = methods.find((m) => REDIRECT_GATEWAYS.has(m.code))?.code;
+    const drive = (code) => DRIVABLE[code] ?? (code === redirect ? { code: "PAYPAL", img: "/payment/card.svg" } : void 0);
     const data = methods.filter((m) => {
-      if (DRIVABLE[m.code]) return true;
+      if (drive(m.code)) return true;
       if (!reported2.has(m.code)) {
         reported2.add(m.code);
         console.warn(
-          `[gocommerce] payment method "${m.code}" is switched on but this storefront cannot drive its flow, so it is not offered.`
+          `[gocommerce] payment method "${m.code}" is switched on but this storefront cannot drive its flow, so it is not offered here; checkoutService.checkout('${m.code}') still reaches it.`
         );
       }
       return false;
     }).map((m, i) => ({
       id: m.code,
-      code: DRIVABLE[m.code].code,
+      code: drive(m.code).code,
       engineCode: m.code,
       name: m.name,
       title: m.name,
       description: "",
-      img: DRIVABLE[m.code].img ?? null,
+      img: drive(m.code).img ?? null,
       rank: i,
       active: true,
       isActive: true
@@ -1944,6 +2048,42 @@ var UserService = class extends BaseService {
     startSession(auth);
     return toUser(auth.record);
   }
+  /**
+   * Mails the signed-in shopper a link to confirm their address. The engine
+   * sends none at signup, and a confirmed address is what customer-group
+   * prices are keyed on. 409 once confirmed; 429 within a minute of the last.
+   */
+  async requestEmailVerification() {
+    return this.account("/x/identity/me/email-verification", { method: "POST", auth: true });
+  }
+  /** Extends the session another thirty days. The token stays the same. */
+  async refreshSession() {
+    return startSession(await this.account("/x/identity/refresh", { method: "POST", auth: true }));
+  }
+  /**
+   * Files a guest order under the signed-in account, so it appears in their
+   * order history. The order's access token is the proof of ownership: pass
+   * it, or leave it out for an order placed from this browser, whose token was
+   * kept at checkout.
+   *
+   * Never done automatically at sign-in. On a shared computer that would file
+   * one person's orders — address and all — under whoever signed in next.
+   */
+  async claimOrder({ number, token }) {
+    const proof = token ?? placedOrder(number)?.token;
+    if (!proof) {
+      throw new GoCommerceError(
+        "This order was not placed from this browser; enter the code from its confirmation.",
+        400
+      );
+    }
+    const order = await this.account("/x/identity/me/orders", {
+      method: "POST",
+      auth: true,
+      body: { number: String(number), token: proof }
+    });
+    return toOrder(order);
+  }
   async deleteUser() {
     throw new NotSupportedError("UserService", "deleteUser", "an account is closed by the store, on request");
   }
@@ -2041,16 +2181,16 @@ var AddressService = class extends BaseService {
       page: env.meta?.page ?? page
     };
   }
-  async fetchAddress(id) {
+  async fetchAddress(id2) {
     return fromIdentityAddress(
-      await this.data(`/x/identity/me/addresses/${enc(id)}`, { auth: true }),
+      await this.data(`/x/identity/me/addresses/${enc(id2)}`, { auth: true }),
       currentMe()?.email
     );
   }
   /** New when it has no id (or the form's `'new'`), an edit when it has one — the storefront saves both here. */
   async saveAddress(address) {
-    const id = address?.id && address.id !== "new" ? String(address.id) : null;
-    if (id) return this.editAddress(id, address);
+    const id2 = address?.id && address.id !== "new" ? String(address.id) : null;
+    if (id2) return this.editAddress(id2, address);
     const a = await this.data("/x/identity/me/addresses", {
       method: "POST",
       auth: true,
@@ -2058,20 +2198,20 @@ var AddressService = class extends BaseService {
     });
     return fromIdentityAddress(a, currentMe()?.email);
   }
-  async editAddress(id, address) {
-    const a = await this.data(`/x/identity/me/addresses/${enc(id)}`, {
+  async editAddress(id2, address) {
+    const a = await this.data(`/x/identity/me/addresses/${enc(id2)}`, {
       method: "PATCH",
       auth: true,
       body: toIdentityAddress(address)
     });
     return fromIdentityAddress(a, currentMe()?.email);
   }
-  async deleteAddress(id) {
-    await this.engine(`/x/identity/me/addresses/${enc(id)}`, { method: "DELETE", auth: true });
-    return { id: String(id), deleted: true };
+  async deleteAddress(id2) {
+    await this.engine(`/x/identity/me/addresses/${enc(id2)}`, { method: "DELETE", auth: true });
+    return { id: String(id2), deleted: true };
   }
 };
-var enc = (id) => encodeURIComponent(String(id));
+var enc = (id2) => encodeURIComponent(String(id2));
 var addressService = new AddressService();
 
 // src/services/wishlist-service.ts
@@ -2123,6 +2263,18 @@ var WishlistService = class extends BaseService {
     const saved = new Set((list?.items ?? []).map((i) => String(i.product_id)));
     return (pairs ?? []).map((p) => ({ ...p, exists: saved.has(String(p.productId)) }));
   }
+  /**
+   * The address the store may write to when a saved product is back in stock
+   * or on sale; `''` takes it off. A list that does not exist yet is made.
+   */
+  async setEmail(email) {
+    const list = await this.current() ?? await this.create();
+    await this.data(`/x/wishlist/${enc2(list.token)}`, {
+      method: "PATCH",
+      body: { email: String(email ?? "").trim() }
+    });
+    return { email: String(email ?? "").trim() || null };
+  }
   async current() {
     const token = wishlistToken();
     if (!token) return null;
@@ -2205,6 +2357,15 @@ var MenuService = class extends BaseService {
     if (menus) return { data: menus };
     return resolveRestLocally("get", "/api/menu");
   }
+  /** Every menu the store keeps, by handle — not only the header and footer. */
+  async listMenus() {
+    return await this.data("/x/navigation/menus") ?? [];
+  }
+  /** One menu by handle, in the storefront's shape: `{ menuId, name, items: [{ id, name, link, items }] }`. */
+  async getMenu(handle) {
+    const m = await this.data(`/x/navigation/menus/${encodeURIComponent(handle)}`);
+    return { menuId: m.handle, name: m.title, items: (m.items ?? []).map(toItem) };
+  }
   /** The header and footer menus, or `null` when the module is not there. Cached: a menu is store-level. */
   async engineMenus() {
     if (!await this.facts.pluginOn("navigation")) return null;
@@ -2226,6 +2387,24 @@ var readStaticStore = async () => {
   return {};
 };
 
+// src/services/newsletter-service.ts
+var NewsletterService = class extends BaseService {
+  async subscribe({ email, name, source }) {
+    return this.data("/x/newsletter/subscribe", {
+      method: "POST",
+      body: { email: String(email ?? "").trim(), ...name ? { name } : {}, ...source ? { source } : {} }
+    });
+  }
+  /** The token from the unsubscribe link in a newsletter email. */
+  async unsubscribe(token) {
+    return this.data("/x/newsletter/unsubscribe", {
+      method: "POST",
+      body: { token: String(token ?? "") }
+    });
+  }
+};
+var newsletterService = new NewsletterService();
+
 // src/services/store-service.ts
 function symbolFor(code) {
   try {
@@ -2259,6 +2438,22 @@ var StoreService = class extends BaseService {
     }
     return super.get(path);
   }
+  /**
+   * The storefront's newsletter box posts `{ email }` to Litekart's
+   * `/api/newsletter/subscribe` through this verb; ext/newsletter is where
+   * that list lives here.
+   */
+  async post(path, data) {
+    if (path.split("?")[0] === "/api/newsletter/subscribe") {
+      const { email, name } = data ?? {};
+      return await new NewsletterService(this._fetch).subscribe({
+        email: email ?? "",
+        name,
+        source: "storefront"
+      });
+    }
+    return super.post(path, data);
+  }
   async live() {
     const [ready, plugins, menus, base] = await Promise.all([
       this.facts.ready(),
@@ -2564,6 +2759,300 @@ var varniCustomProductService = new VarniCustomProductService();
 var pluginsService = pluginService;
 var settingsService = settingService;
 
-export { AddressService, AuthService, AutocompleteService, BannerService, BaseService, BlogService, CartService, CatalogService, CategoryService, ChatService, CheckoutService, CollectionService, ContactService, CountryService, CouponService, CurrencyService, DealService, DemoRequestService, EnquiryService, FaqService, FeedbackService, GalleryService, HomeService, InitService, MeilisearchService, MenuService, OrderService, PageService, PaymentMethodService, PluginService, PluginService as PluginsService, PopularSearchService, PopularityService, ProductService, ProfileService, ReelsService, RegionService, ReviewService, SearchService, SettingService, SettingService as SettingsService, StateService, StoreService, UploadService, UserService, VarniCustomDesignService, VarniCustomProductService, VendorService, WarrantyService, WishlistService, addressService, authService, autocompleteService, bannerService, blogService, cartService, categoryService, chatService, checkoutService, collectionService, contactService, countryService, couponService, currencyService, dealService, demoRequestService, emptyPage, enquiryService, faqService, feedbackService, galleryService, homeService, initService, meilisearchService, menuService, orderService, pageService, paymentMethodService, pluginService, pluginsService, popularSearchService, popularityService, productService, profileService, qs, reelsService, regionService, reviewService, searchService, settingService, settingsService, stateService, staticStore, storeService, toPage, uploadService, userService, varniCustomDesignService, varniCustomProductService, vendorService, warrantyService, wishlistService };
+// src/services/variant-service.ts
+var VariantService = class extends BaseService {
+  /** A product's variants, inactive ones included (filter on `active`), in the merchant's order. */
+  async list(productId, { page = 1, limit = 50 } = {}) {
+    const env = await this.engine("/api/variants", { query: { product_id: productId, page, limit } });
+    return { data: (env.data ?? []).map(withAmounts), meta: env.meta };
+  }
+  async getOne(id2) {
+    return withAmounts(await this.data(`/api/variants/${encodeURIComponent(String(id2))}`));
+  }
+  /**
+   * What each approved seller asks for this variant, cheapest first. A cart
+   * line takes a variant, not an offer, so this informs a shopper rather than
+   * choosing who fulfils.
+   */
+  async offers(variantId) {
+    const offers = await this.data(`/api/variants/${encodeURIComponent(String(variantId))}/offers`) ?? [];
+    return offers.map((o) => ({ ...o, price: { ...o.price, amount: toMajor(o.price) } }));
+  }
+};
+function withAmounts(v) {
+  return {
+    ...v,
+    price: { ...v.price, amount: toMajor(v.price) },
+    compare_at_price: v.compare_at_price ? { ...v.compare_at_price, amount: toMajor(v.compare_at_price) } : void 0
+  };
+}
+var variantService = new VariantService();
+
+// src/services/b2b-service.ts
+var B2bService = class extends BaseService {
+  // ------------------------------------------------------------ company
+  /** The company, the caller's role in it, and its credit: limit, outstanding, available, overdue. */
+  async me() {
+    const me = await this.data("/x/b2b/me", { auth: true });
+    const { notes: _notes, metadata: _metadata, ...company } = me.company;
+    return { company, role: me.role, credit: me.credit };
+  }
+  async members() {
+    return await this.data("/x/b2b/members", { auth: true }) ?? [];
+  }
+  /** Admin only. Demoting the last admin is refused (409). */
+  async setMemberRole(customerId, role) {
+    return this.data(`/x/b2b/members/${id(customerId)}`, { method: "PATCH", auth: true, body: { role } });
+  }
+  /** An admin removes anyone; any member may remove themselves. */
+  async removeMember(customerId) {
+    await this.engine(`/x/b2b/members/${id(customerId)}`, { method: "DELETE", auth: true });
+  }
+  // ------------------------------------------------------------ invitations
+  /** Admin only. Open invitations: not accepted, not expired. */
+  async invitations() {
+    return await this.data("/x/b2b/invitations", { auth: true }) ?? [];
+  }
+  /** Admin only. Emails a link; a second invitation to the same address replaces the first. */
+  async invite({ email, role }) {
+    return this.data("/x/b2b/invitations", {
+      method: "POST",
+      auth: true,
+      body: { email: String(email ?? "").trim(), role }
+    });
+  }
+  async withdrawInvitation(invitationId) {
+    await this.engine(`/x/b2b/invitations/${id(invitationId)}`, { method: "DELETE", auth: true });
+  }
+  /**
+   * The token from the invitation email, accepted by the account it was sent
+   * to — which also confirms that account's email address.
+   */
+  async acceptInvitation(token) {
+    return this.data("/x/b2b/invitations/accept", {
+      method: "POST",
+      auth: true,
+      body: { token: String(token ?? "").trim() }
+    });
+  }
+  // ------------------------------------------------------------ filling a basket
+  /**
+   * A quick order: up to 500 lines by SKU or variant id, into the bag (or a new
+   * one), at the company's prices. A line that will not go in is reported in
+   * `rejected` with its reason; the rest are added.
+   */
+  async addLines({
+    cartId,
+    lines
+  }) {
+    const res = await this.data("/x/b2b/cart/lines", {
+      method: "POST",
+      auth: true,
+      body: {
+        ...cartId ?? storedCartId() ? { cart_id: cartId ?? storedCartId() } : {},
+        lines: (lines ?? []).map((l) => ({
+          ...l.variantId ? { variant_id: Number(l.variantId) } : {},
+          ...l.sku ? { sku: String(l.sku).trim() } : {},
+          quantity: Number(l.quantity)
+        }))
+      }
+    });
+    rememberCartId(res.cart.id);
+    return { cart: toCart(res.cart, cartExtras(res.cart.id)), rejected: res.rejected ?? [] };
+  }
+  /** A past order's lines in a new bag, at today's prices. Nothing is placed. */
+  async reorder(orderId) {
+    const res = await this.data(
+      `/x/b2b/orders/${id(orderId)}/reorder`,
+      {
+        method: "POST",
+        auth: true
+      }
+    );
+    rememberCartId(res.cart.id);
+    return { cart: toCart(res.cart, cartExtras(res.cart.id)), rejected: res.rejected ?? [] };
+  }
+  // ------------------------------------------------------------ placing an order
+  /**
+   * Places the bag through the company: on account by default, with a PO
+   * number, optionally only some lines (`lineIds`). A buyer over the company's
+   * approval threshold gets `{ kind: 'approval' }` instead of an order — the
+   * bag stays as it was, and an approver places it later.
+   *
+   * Over the credit limit is 403 `credit_limit_exceeded`; `me().credit` says
+   * how much is available before the shopper tries.
+   */
+  async checkout({
+    cartId,
+    lineIds,
+    shippingRateId,
+    returnUrl,
+    paymentData,
+    ...opts
+  } = {}) {
+    const cart = cartId || storedCartId();
+    if (!cart) throw new GoCommerceError("Your bag is empty.", 400);
+    const extras = cartExtras(cart);
+    const rate = shippingRateId ?? extras.shippingRateId;
+    const body = {
+      cart_id: cart,
+      ...this.placeBody(opts, extras.shippingAddress ?? void 0),
+      ...rate ? { shipping_rate_id: Number(rate) } : {},
+      ...lineIds?.length ? { line_ids: lineIds.map(Number) } : {},
+      ...returnUrl ? { return_url: returnUrl } : {},
+      ...paymentData ? { payment_data: paymentData } : {}
+    };
+    const res = await this.data("/x/b2b/checkout", {
+      method: "POST",
+      auth: true,
+      body,
+      headers: { "Idempotency-Key": attemptKey(`b2b:${JSON.stringify(body)}`) }
+    });
+    return this.placed(res, cart);
+  }
+  // ------------------------------------------------------------ the company's orders
+  /** Admins and approvers see the company's; a buyer sees their own. `q` matches the number, PO or email. */
+  async orders({
+    page = 1,
+    limit = 20,
+    q,
+    overdue
+  } = {}) {
+    return this.engine("/x/b2b/orders", {
+      auth: true,
+      query: { page, limit, q, ...overdue ? { overdue: "true" } : {} }
+    });
+  }
+  // ------------------------------------------------------------ approvals
+  async approvals({
+    page = 1,
+    limit = 20,
+    status
+  } = {}) {
+    return this.engine("/x/b2b/approvals", { auth: true, query: { page, limit, status } });
+  }
+  async approval(approvalId) {
+    return this.data(`/x/b2b/approvals/${id(approvalId)}`, { auth: true });
+  }
+  /**
+   * Admin or approver: places the requested order at the prices it was
+   * requested at. Credit limits and holds still apply. The payment intent is
+   * the approver's to act on — for an account order there is nothing to do.
+   */
+  async approve(approvalId) {
+    const res = await this.data(`/x/b2b/approvals/${id(approvalId)}/approve`, {
+      method: "POST",
+      auth: true
+    });
+    return { approval: res.approval, orderNo: res.order.number, order: toOrder(res.order), payment: res.payment };
+  }
+  async reject(approvalId, reason) {
+    return this.data(`/x/b2b/approvals/${id(approvalId)}/reject`, {
+      method: "POST",
+      auth: true,
+      ...reason ? { body: { reason } } : {}
+    });
+  }
+  /** The buyer who asked withdraws the request. */
+  async cancelApproval(approvalId) {
+    return this.data(`/x/b2b/approvals/${id(approvalId)}/cancel`, { method: "POST", auth: true });
+  }
+  // ------------------------------------------------------------ quotes
+  async quotes({ page = 1, limit = 20, status } = {}) {
+    return this.engine("/x/b2b/quotes", { auth: true, query: { page, limit, status } });
+  }
+  async quote(quoteId) {
+    return this.data(`/x/b2b/quotes/${id(quoteId)}`, { auth: true });
+  }
+  /** Asks the store to price these lines. The store answers with unit prices and an expiry. */
+  async requestQuote({ lines, note }) {
+    return this.data("/x/b2b/quotes", {
+      method: "POST",
+      auth: true,
+      body: {
+        lines: (lines ?? []).map((l) => ({ variant_id: Number(l.variantId), quantity: Number(l.quantity) })),
+        ...note ? { note } : {}
+      }
+    });
+  }
+  /** Places the quote at its agreed prices — or, for a buyer over the threshold, asks for approval. */
+  async acceptQuote(quoteId, opts = {}) {
+    const res = await this.data(`/x/b2b/quotes/${id(quoteId)}/accept`, {
+      method: "POST",
+      auth: true,
+      body: this.placeBody(opts)
+    });
+    return this.placed(res);
+  }
+  async declineQuote(quoteId) {
+    return this.data(`/x/b2b/quotes/${id(quoteId)}/decline`, { method: "POST", auth: true });
+  }
+  // ------------------------------------------------------------ dealer leads
+  /**
+   * The public "find a dealer" form: no account needed. The engine routes it to
+   * the dealer whose territory covers the address — or keeps it — and answers
+   * the same either way, so the form never reveals who got it.
+   */
+  async submitLead(lead) {
+    return this.data("/x/b2b/leads", {
+      method: "POST",
+      body: {
+        ...lead.name ? { name: lead.name } : {},
+        ...lead.email ? { email: lead.email } : {},
+        ...lead.phone ? { phone: lead.phone } : {},
+        ...lead.message ? { message: lead.message } : {},
+        ...lead.country ? { country: lead.country } : {},
+        ...lead.state ? { state: lead.state } : {},
+        ...lead.postalCode ? { postal_code: lead.postalCode } : {},
+        ...lead.productId ? { product_id: Number(lead.productId) } : {},
+        ...lead.variantId ? { variant_id: Number(lead.variantId) } : {},
+        ...lead.source ? { source: lead.source } : {}
+      }
+    });
+  }
+  /** A dealer's admins and approvers: the leads routed to their company. */
+  async leads({ page = 1, limit = 20, status } = {}) {
+    return this.engine("/x/b2b/leads", { auth: true, query: { page, limit, status } });
+  }
+  async setLeadStatus(leadId, status) {
+    return this.data(`/x/b2b/leads/${id(leadId)}`, { method: "PATCH", auth: true, body: { status } });
+  }
+  // ------------------------------------------------------------ internals
+  /** The fields checkout and quote acceptance share. Only declared ones: the engine refuses the rest. */
+  placeBody(opts, fallback) {
+    const raw = opts.address ?? fallback;
+    if (!raw) throw new GoCommerceError("Add a delivery address first.", 400);
+    const address = "line1" in raw ? raw : toEngineAddress(raw);
+    return {
+      address,
+      ...opts.paymentMethod ? { payment_method: String(opts.paymentMethod).toLowerCase() } : {},
+      ...opts.poNumber ? { po_number: String(opts.poNumber).trim() } : {},
+      ...opts.name ?? address.name ? { name: opts.name ?? address.name } : {},
+      ...opts.phone ?? address.phone ? { phone: opts.phone ?? address.phone } : {}
+    };
+  }
+  placed(res, cartId) {
+    if (res.approval && !res.order) return { kind: "approval", approval: res.approval };
+    const order = res.order;
+    if (order.access_token && cartId) {
+      rememberOrder({ number: order.number, token: order.access_token, cartId, reference: res.payment?.reference });
+    }
+    return { kind: "order", orderNo: order.number, order: toOrder(order), payment: res.payment };
+  }
+};
+var id = (v) => encodeURIComponent(String(v));
+var keys = /* @__PURE__ */ new Map();
+function attemptKey(request) {
+  let key = keys.get(request);
+  if (!key) {
+    const c = globalThis.crypto;
+    key = c?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    keys.set(request, key);
+  }
+  return key;
+}
+var b2bService = new B2bService();
+
+export { AddressService, AuthService, AutocompleteService, B2bService, BannerService, BaseService, BlogService, CartService, CatalogService, CategoryService, ChatService, CheckoutService, CollectionService, ContactService, CountryService, CouponService, CurrencyService, DealService, DemoRequestService, EnquiryService, FaqService, FeedbackService, GalleryService, HomeService, InitService, MeilisearchService, MenuService, NewsletterService, OrderService, PageService, PaymentMethodService, PluginService, PluginService as PluginsService, PopularSearchService, PopularityService, ProductService, ProfileService, REDIRECT_GATEWAYS, ReelsService, RegionService, ReviewService, SearchService, SettingService, SettingService as SettingsService, StateService, StoreService, UploadService, UserService, VariantService, VarniCustomDesignService, VarniCustomProductService, VendorService, WarrantyService, WishlistService, addressService, authService, autocompleteService, b2bService, bannerService, blogService, cartService, categoryService, chatService, checkoutService, collectionService, contactService, countryService, couponService, currencyService, dealService, demoRequestService, emptyPage, enquiryService, faqService, feedbackService, galleryService, homeService, initService, meilisearchService, menuService, newsletterService, orderService, pageService, paymentMethodService, pluginService, pluginsService, popularSearchService, popularityService, productService, profileService, qs, reelsService, regionService, reviewService, searchService, settingService, settingsService, stateService, staticStore, storeService, toPage, uploadService, userService, variantService, varniCustomDesignService, varniCustomProductService, vendorService, warrantyService, wishlistService };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map