@estoreclub/api 0.0.0-stage → 0.1.0

package/dist/chunks/chunk-5DN7L6LX.js

@@ -0,0 +1,861 @@
+import {
+  memoGet
+} from "./chunk-2BH4QPV2.js";
+import {
+  normalCountry,
+  resolveVisitorCountry
+} from "./chunk-2554RPSS.js";
+import {
+  getCompanyApiKey
+} from "./chunk-TSERNR4R.js";
+import {
+  resolveCustomerToken
+} from "./chunk-OFFTL6RC.js";
+import {
+  PublicApiError,
+  refusalFactsOf
+} from "./chunk-GJZ7EZEF.js";
+import {
+  resolveLanguage
+} from "./chunk-HFEQWXG6.js";
+import {
+  flag,
+  idOrName,
+  include,
+  oneOf,
+  paging,
+  segment,
+  text,
+  trimSlash,
+  whole
+} from "./chunk-3KEEGSMP.js";
+
+// packages/api/src/client.ts
+var COMMENT_MAX_LENGTH = 2e3;
+var CATEGORY_INCLUDES = [
+  "translations",
+  "media",
+  "count"
+];
+var PRODUCT_INCLUDES = [
+  "translations",
+  "media",
+  "categories",
+  "settings"
+];
+var PRODUCT_SORTS = [
+  "custom",
+  "name",
+  "price",
+  "popularity",
+  "discount"
+];
+var DEFAULT_TIMEOUT_MS = 2e3;
+var STRIPE_TIMEOUT_MS = 15e3;
+var MAX_QUANTITY = 99;
+function createPublicApiClient(config) {
+  const call = requester(config);
+  const send = writer(config);
+  const companyRecord = companyResolver(config);
+  return {
+    getCompany: async () => strip(await companyRecord()),
+    getSiteInfo: async () => {
+      const company = await companyRecord();
+      return {
+        siteName: company.name,
+        defaultLanguage: company.defaultLanguage,
+        languages: company.languages ?? [],
+        currency: company.defaultCurrency,
+        countryCode: company.countryCode ?? null,
+        // Per request, not per company: asked of the render, never of the API.
+        visitorCountry: config.visitorCountry === null ? null : normalCountry(config.visitorCountry) ?? resolveVisitorCountry(),
+        currencySymbol: company.currencySymbol,
+        currencySymbolPosition: company.currencySymbolPosition,
+        taxRate: company.taxRate ?? 0,
+        taxInclusive: company.taxInclusive ?? true,
+        taxName: company.taxName ?? "Tax",
+        orderLocation: company.orderLocation ?? "optional",
+        orderTypes: company.orderTypes ?? ["pickup"],
+        reservationMode: company.reservationMode ?? "off",
+        reservationKinds: company.reservationKinds ?? [],
+        // Deprecated, for sites written before: no longer sent by the server.
+        tableReservations: (company.reservationMode ?? "off") !== "off",
+        customerSignIn: true,
+        // `apple` is false from a server that predates it.
+        customerSignInMethods: {
+          apple: false,
+          ...company.customerSignInMethods ?? { email: false, google: true }
+        },
+        customerAccess: company.customerAccess ?? "public",
+        reservationRequiresSignIn: company.reservationRequiresSignIn ?? false,
+        reservationOrder: company.reservationOrder ?? "off",
+        reservationPayment: company.reservationPayment ?? {
+          order: false,
+          deferred: false
+        },
+        orderRequiresSignIn: company.orderRequiresSignIn ?? false,
+        publicOrderTracking: company.publicOrderTracking ?? false,
+        paymentDiscounts: company.paymentDiscounts ?? {
+          online: null,
+          inStore: null
+        },
+        googleClientId: company.googleClientId ?? null,
+        googleSignInUrl: company.googleSignInUrl ?? null,
+        appleClientId: company.appleClientId ?? null,
+        appleSignInUrl: company.appleSignInUrl ?? null,
+        settings: company.settings
+      };
+    },
+    getCategories: async (params = {}) => {
+      const list = await call("product-categories", {
+        ...text("search", params.search),
+        ...include(params.include, CATEGORY_INCLUDES)
+      });
+      const limit = Number(params.limit);
+      if (!Array.isArray(list)) return [];
+      return Number.isFinite(limit) && limit > 0 ? list.slice(0, limit) : list;
+    },
+    getCategory: async (params) => (
+      // The name goes in the QUERY, not the path. It is whatever the shop typed — any
+      // language, any script, possibly a slash — and a path segment carries that only as
+      // percent-encoded UTF-8 that proxies, logs and humans all handle worse than a query
+      // parameter does.
+      call("product-categories/by-identifier", {
+        ...idOrName(params),
+        ...include(params.include, CATEGORY_INCLUDES)
+      })
+    ),
+    getProducts: async (params = {}) => {
+      const page = await call("products", {
+        ...paging(params),
+        ...text("categoryId", params.categoryId),
+        ...text("categoryName", params.categoryName),
+        ...text("search", params.search),
+        ...text("tags", params.tags),
+        ...flag("categoryEmpty", params.categoryEmpty),
+        ...oneOf("sortBy", params.sortBy, PRODUCT_SORTS),
+        ...oneOf("sortOrder", params.sortOrder, ["ASC", "DESC"]),
+        ...whole("popularityDays", params.popularityDays, 1, 365),
+        ...include(params.include, PRODUCT_INCLUDES)
+      });
+      return { ...page, data: (page?.data ?? []).map(priced) };
+    },
+    getProduct: async (params) => priced(
+      await call("products/by-identifier", idOrName(params))
+    ),
+    getProductSettings: async (params = {}) => {
+      const answer = await call("products/settings", flag("tagsOnly", params.tagsOnly));
+      return Array.isArray(answer?.settings) ? answer.settings : [];
+    },
+    listDictionaries: async () => {
+      const list = await call("dictionaries");
+      return Array.isArray(list) ? list : [];
+    },
+    getTerms: async (params = {}) => call(
+      "terms",
+      params.language ? { language: params.language } : {}
+    ),
+    getDiningTable: async ({ tableId }) => call(`tables/${segment(tableId, "tableId")}`),
+    verifyDiningTableCode: async ({ tableId, code }) => send("POST", `tables/${segment(tableId, "tableId")}/code`, {}, { code }),
+    getLocations: async () => {
+      const answer = await call("locations");
+      return Array.isArray(answer?.data) ? answer.data : [];
+    },
+    getCombos: async (params = {}) => {
+      const answer = await call("combos", {
+        ...params.categoryId ? { categoryId: segment(params.categoryId, "categoryId") } : {}
+      });
+      return Array.isArray(answer?.data) ? answer.data : [];
+    },
+    getDiscountRules: async () => {
+      const answer = await call(
+        "discount-rules"
+      );
+      return Array.isArray(answer?.data) ? answer.data : [];
+    },
+    getDictionary: async (params) => call("dictionaries/by-identifier", idOrName(params)),
+    getDictionaries: async (params) => params.identifiers.length === 0 ? [] : call("dictionaries/by-identifiers", {
+      identifiers: params.identifiers.join(",")
+    }),
+    lookupImages: async (params) => {
+      const urls = Array.from(new Set(params.urls.filter(Boolean))).slice(
+        0,
+        200
+      );
+      return urls.length === 0 ? [] : send(
+        "POST",
+        "images/lookup",
+        {},
+        { urls: urls.sort() }
+      );
+    },
+    getOrderTimes: async (params = {}) => call("checkout/times", {
+      ...params.locationId ? { locationId: segment(params.locationId, "locationId") } : {}
+    }),
+    getBookingSlots: async (params) => call("bookings/slots", {
+      locationId: segment(params.locationId, "locationId"),
+      date: params.date,
+      partySize: String(params.partySize),
+      ...params.seating ? { seating: params.seating } : {},
+      ...params.timeZone ? { timeZone: params.timeZone } : {},
+      ...params.tableId ? { tableId: segment(params.tableId, "tableId") } : {},
+      ...params.durationMinutes ? { durationMinutes: String(params.durationMinutes) } : {},
+      ...params.entryId ? { entryId: segment(params.entryId, "entryId") } : {},
+      ...params.entryIds?.length ? {
+        entryIds: params.entryIds.map((id) => segment(id, "entryIds")).join(",")
+      } : {},
+      ...params.productId ? { productId: segment(params.productId, "productId") } : {},
+      ...params.productIds?.length ? {
+        productIds: params.productIds.map((id) => segment(id, "productIds")).join(",")
+      } : {},
+      ...params.kind ? { kind: params.kind } : {}
+    }),
+    getBookingPlan: async (params) => call("bookings/plan", {
+      locationId: segment(params.locationId, "locationId"),
+      startsAt: params.startsAt,
+      partySize: String(params.partySize),
+      ...params.seating ? { seating: params.seating } : {},
+      ...params.durationMinutes ? { durationMinutes: String(params.durationMinutes) } : {},
+      ...params.kind ? { kind: params.kind } : {}
+    }),
+    createBooking: async ({ customerToken, ...params }) => send(
+      "POST",
+      "bookings",
+      {},
+      params,
+      void 0,
+      token(customerToken)
+    ),
+    requestSignInCode: async (params) => send(
+      "POST",
+      "customers/sign-in/code",
+      {},
+      { email: requiredEmail(params.email) }
+    ),
+    verifySignInCode: async (params) => send(
+      "POST",
+      "customers/sign-in/verify",
+      {},
+      {
+        email: requiredEmail(params.email),
+        code: signInCode(params.code)
+      }
+    ),
+    signInWithGoogle: async (params) => send(
+      "POST",
+      "customers/sign-in/google",
+      {},
+      { idToken: textOf(params.idToken, "idToken", 4096) }
+    ),
+    signInWithApple: async (params) => send(
+      "POST",
+      "customers/sign-in/apple",
+      {},
+      {
+        idToken: textOf(params.idToken, "idToken", 4096),
+        ...params.name?.trim() ? { name: textOf(params.name.trim(), "name", 200) } : {}
+      }
+    ),
+    refreshCustomerToken: async (params) => send(
+      "POST",
+      "customers/token/refresh",
+      {},
+      { refreshToken: textOf(params.refreshToken, "refreshToken", 128) }
+    ),
+    signOutCustomer: async (params) => send(
+      "POST",
+      "customers/sign-out",
+      {},
+      { refreshToken: textOf(params.refreshToken, "refreshToken", 128) }
+    ),
+    getCustomerAccount: async (params) => call(
+      "customers/me",
+      {},
+      void 0,
+      requiredToken(params.customerToken)
+    ),
+    getCustomerOrders: async ({ customerToken, page, limit }) => call(
+      "customers/me/orders",
+      historyQuery(page, limit),
+      void 0,
+      requiredToken(customerToken)
+    ),
+    getCustomerOrder: async ({ customerToken, orderId }) => call(
+      `customers/me/orders/${segment(orderId, "orderId")}`,
+      {},
+      void 0,
+      requiredToken(customerToken)
+    ),
+    getCustomerBookings: async ({ customerToken, scope, page, limit }) => call(
+      "customers/me/bookings",
+      {
+        ...historyQuery(page, limit),
+        ...oneOf("scope", scope, ["upcoming", "past", "all"])
+      },
+      void 0,
+      requiredToken(customerToken)
+    ),
+    cancelCustomerBooking: async ({ customerToken, bookingId }) => send(
+      "POST",
+      `customers/me/bookings/${segment(bookingId, "bookingId")}/cancel`,
+      {},
+      void 0,
+      void 0,
+      requiredToken(customerToken)
+    ),
+    setCustomerBookingPreorder: async ({ customerToken, bookingId, lines }) => send(
+      "PUT",
+      `customers/me/bookings/${segment(bookingId, "bookingId")}/preorder`,
+      {},
+      { lines },
+      void 0,
+      requiredToken(customerToken)
+    ),
+    getCustomerAddresses: async ({ customerToken }) => call(
+      "customers/me/addresses",
+      {},
+      void 0,
+      requiredToken(customerToken)
+    ),
+    addCustomerAddress: async ({
+      customerToken,
+      address,
+      details,
+      latitude,
+      longitude,
+      postcode
+    }) => send(
+      "POST",
+      "customers/me/addresses",
+      {},
+      {
+        address,
+        ...details !== void 0 ? { details } : {},
+        ...latitude !== void 0 ? { latitude } : {},
+        ...longitude !== void 0 ? { longitude } : {},
+        ...postcode !== void 0 ? { postcode } : {}
+      },
+      void 0,
+      requiredToken(customerToken)
+    ),
+    deleteCustomerAddress: async ({ customerToken, customerAddressId }) => send(
+      "DELETE",
+      `customers/me/addresses/${segment(customerAddressId, "customerAddressId")}`,
+      {},
+      void 0,
+      void 0,
+      requiredToken(customerToken)
+    ),
+    getCustomerPaymentMethods: async ({ customerToken }) => call(
+      "customers/me/payment-methods",
+      {},
+      void 0,
+      requiredToken(customerToken)
+    ),
+    deleteCustomerPaymentMethod: async ({ customerToken, paymentMethodId }) => send(
+      "DELETE",
+      `customers/me/payment-methods/${segment(paymentMethodId, "paymentMethodId")}`,
+      {},
+      void 0,
+      void 0,
+      requiredToken(customerToken)
+    ),
+    getCustomerFavourites: async ({ customerToken, ...params }) => {
+      const page = await call(
+        "customers/me/favourites",
+        {
+          ...paging(params),
+          ...text("categoryId", params.categoryId),
+          ...text("categoryName", params.categoryName),
+          ...text("search", params.search),
+          ...text("tags", params.tags),
+          ...oneOf("sortBy", params.sortBy, PRODUCT_SORTS),
+          ...oneOf("sortOrder", params.sortOrder, ["ASC", "DESC"]),
+          ...include(params.include, PRODUCT_INCLUDES)
+        },
+        void 0,
+        requiredToken(customerToken)
+      );
+      return { ...page, data: (page?.data ?? []).map(priced) };
+    },
+    getCustomerFavouriteIds: async ({ customerToken }) => call(
+      "customers/me/favourites/ids",
+      {},
+      void 0,
+      requiredToken(customerToken)
+    ),
+    addCustomerFavourite: async ({ customerToken, productId }) => send(
+      "PUT",
+      `customers/me/favourites/${segment(productId, "productId")}`,
+      {},
+      void 0,
+      void 0,
+      requiredToken(customerToken)
+    ),
+    removeCustomerFavourite: async ({ customerToken, productId }) => send(
+      "DELETE",
+      `customers/me/favourites/${segment(productId, "productId")}`,
+      {},
+      void 0,
+      void 0,
+      requiredToken(customerToken)
+    ),
+    updateCustomerProfile: async ({
+      customerToken,
+      name,
+      phone,
+      dateOfBirth,
+      acceptTerms,
+      healthConsent,
+      language
+    }) => send(
+      "PATCH",
+      "customers/me",
+      {},
+      {
+        ...name !== void 0 ? { name: name ?? "" } : {},
+        ...phone !== void 0 ? { phone: phone ?? "" } : {},
+        ...dateOfBirth !== void 0 ? { dateOfBirth: dateOfBirth ?? "" } : {},
+        ...acceptTerms === true ? { acceptTerms: true } : {},
+        ...typeof healthConsent === "boolean" ? { healthConsent } : {},
+        ...language !== void 0 ? { language: language ?? "" } : {}
+      },
+      void 0,
+      requiredToken(customerToken)
+    ),
+    getProductFeedback: async ({ productId, customerToken }) => call(
+      `products/${segment(productId, "productId")}/feedback`,
+      {},
+      void 0,
+      token(customerToken)
+    ),
+    getProductComments: async ({
+      productId,
+      parentId,
+      page,
+      limit,
+      customerToken
+    }) => call(
+      parentId ? `products/${segment(productId, "productId")}/comments/${segment(parentId, "parentId")}/replies` : `products/${segment(productId, "productId")}/comments`,
+      historyQuery(page, limit),
+      void 0,
+      token(customerToken)
+    ),
+    createProductComment: async ({
+      customerToken,
+      productId,
+      body,
+      parentId,
+      vote
+    }) => send(
+      "POST",
+      `products/${segment(productId, "productId")}/comments`,
+      {},
+      {
+        body: textOf(body, "body", COMMENT_MAX_LENGTH),
+        ...parentId ? { parentId: segment(parentId, "parentId") } : {},
+        // A vote rides on a root comment only - a reply is not a review.
+        ...vote != null && !parentId ? { vote: voteValue(vote, false) } : {}
+      },
+      void 0,
+      requiredToken(customerToken)
+    ),
+    deleteProductComment: async ({ customerToken, productId, commentId }) => send(
+      "DELETE",
+      `products/${segment(productId, "productId")}/comments/${segment(commentId, "commentId")}`,
+      {},
+      void 0,
+      void 0,
+      requiredToken(customerToken)
+    ),
+    rateProduct: async ({ customerToken, productId, value }) => send(
+      "PUT",
+      `products/${segment(productId, "productId")}/rating`,
+      {},
+      { value: voteValue(value, false) },
+      void 0,
+      requiredToken(customerToken)
+    ),
+    unrateProduct: async ({ customerToken, productId }) => send(
+      "DELETE",
+      `products/${segment(productId, "productId")}/rating`,
+      {},
+      void 0,
+      void 0,
+      requiredToken(customerToken)
+    ),
+    voteProductComment: async ({
+      customerToken,
+      productId,
+      commentId,
+      value
+    }) => send(
+      "PUT",
+      `products/${segment(productId, "productId")}/comments/${segment(commentId, "commentId")}/vote`,
+      {},
+      { value: voteValue(value, true) },
+      void 0,
+      requiredToken(customerToken)
+    ),
+    createCart: async () => send("POST", "cart"),
+    getCart: async (params) => call("cart", cart(params.cartId)),
+    addCartItem: async (params) => send(
+      "POST",
+      "cart/items",
+      cart(params.cartId),
+      params.comboId ? {
+        comboId: segment(params.comboId, "comboId"),
+        picks: (params.picks ?? []).map(pick),
+        quantity: quantity(params.quantity ?? 1, 1)
+      } : {
+        productId: segment(params.productId, "productId"),
+        quantity: quantity(params.quantity ?? 1, 1),
+        ...params.variantId ? { variantId: segment(params.variantId, "variantId") } : {},
+        variant: typeof params.variant === "string" ? params.variant : ""
+      }
+    ),
+    setCartItemQuantity: async (params) => send(
+      "PATCH",
+      `cart/items/${segment(params.cartItemId, "cartItemId")}`,
+      cart(params.cartId),
+      { quantity: quantity(params.quantity, 0) }
+    ),
+    removeCartItem: async (params) => send(
+      "DELETE",
+      `cart/items/${segment(params.cartItemId, "cartItemId")}`,
+      cart(params.cartId)
+    ),
+    setCartBooking: async (params) => send("PUT", "cart/booking", cart(params.cartId), {
+      bookingId: params.bookingId ? segment(params.bookingId, "bookingId") : null
+    }),
+    destroyCart: async (params) => {
+      await send("DELETE", "cart", cart(params.cartId));
+    },
+    getCheckout: async (params) => call(
+      `hosted-checkout/${segment(params.checkoutId, "checkoutId")}`,
+      {},
+      // Reads the session back from Stripe, so it waits on the same network the write does.
+      STRIPE_TIMEOUT_MS
+    ),
+    trackOrder: async (params) => call("orders/track", trackQuery(params)),
+    setCheckoutEmail: async (params) => {
+      const email = customerEmail(params.email).customerEmail;
+      if (!email) throw new Error("invalid email");
+      return send(
+        "PUT",
+        `hosted-checkout/${segment(params.checkoutId, "checkoutId")}/email`,
+        {},
+        { email },
+        STRIPE_TIMEOUT_MS
+      );
+    },
+    createCheckout: async (params) => send(
+      "POST",
+      "checkout",
+      {},
+      {
+        cartId: segment(params.cartId, "cartId"),
+        ...customerEmail(params.customerEmail),
+        ...params.customerPhone?.trim() ? { customerPhone: params.customerPhone.trim().slice(0, 32) } : {},
+        ...params.notes?.trim() ? { notes: params.notes.trim().slice(0, 500) } : {},
+        ...returnUrl("successUrl", params.successUrl),
+        ...returnUrl("cancelUrl", params.cancelUrl),
+        ...params.locationId ? { locationId: segment(params.locationId, "locationId") } : {},
+        ...params.orderType ? { orderType: params.orderType } : {},
+        ...params.scheduledFor ? { scheduledFor: params.scheduledFor } : {},
+        ...params.bookingId ? { bookingId: segment(params.bookingId, "bookingId") } : {},
+        ...params.tableId ? { tableId: segment(params.tableId, "tableId") } : {},
+        ...params.tableCode ? { tableCode: params.tableCode } : {},
+        ...params.allowTimeChoice === false ? { allowTimeChoice: false } : {},
+        ...params.allowOrderTypeChoice === false ? { allowOrderTypeChoice: false } : {},
+        ...params.allowPaymentMethodChoice === false ? { allowPaymentMethodChoice: false } : {},
+        ...params.paymentMethod ? { paymentMethod: params.paymentMethod } : {},
+        ...params.promoCode?.trim() ? { promoCode: params.promoCode.trim() } : {},
+        // The language the payment page will be written in, and the one the line names are
+        // snapshotted in. Defaulted to the language this client is reading in rather than
+        // left to each site to remember: a shopper who got this far in Russian has already
+        // been answered in Russian by every other call, and a checkout in English after that
+        // is a page that changed language at the till.
+        ...await checkoutLanguage(config, params.language)
+      },
+      STRIPE_TIMEOUT_MS,
+      token(params.customerToken)
+    )
+  };
+  function cart(cartId) {
+    return { cartId: segment(cartId, "cartId") };
+  }
+  function strip(company) {
+    const { apiKey: _key, ...rest } = company;
+    return rest;
+  }
+}
+function priced(product) {
+  const withVariants = product?.variants ? { ...product, variants: product.variants.map(pricedVariant) } : product;
+  return pricedPrice(withVariants);
+}
+function pricedVariant(variant) {
+  return pricedPrice(variant);
+}
+function pricedPrice(item) {
+  const raw = item?.price;
+  if (typeof raw === "number") return item;
+  const parsed = typeof raw === "string" ? Number(raw) : Number.NaN;
+  if (!Number.isFinite(parsed)) {
+    if (raw === void 0) return item;
+    const { price: _dropped, ...rest } = item;
+    return rest;
+  }
+  return { ...item, price: parsed };
+}
+function keyFor(config) {
+  const key = config.companyApiKey ?? getCompanyApiKey();
+  if (!key && !config.productSample) {
+    throw new PublicApiError("no key - supply companyApiKey");
+  }
+  return key ?? "";
+}
+function request(config, method, url, key, body, timeoutMs, language, customerToken) {
+  const once = () => fetchOnce(
+    config,
+    method,
+    url,
+    key,
+    body,
+    timeoutMs,
+    language,
+    customerToken
+  );
+  const isRead = method === "GET" || READ_POSTS.has(resourceOf(url));
+  if (isRead) {
+    const scope = `${key}\0${config.productSample ?? ""}\0${language ?? ""}\0${customerToken ?? ""}\0${method} ${url}${method === "GET" ? "" : `\0${JSON.stringify(body ?? null)}`}`;
+    return memoGet(scope, once);
+  }
+  return once();
+}
+var READ_POSTS = /* @__PURE__ */ new Set(["images/lookup"]);
+function resourceOf(url) {
+  const path = url.split("?")[0];
+  const at = path.indexOf("/api/public/");
+  return at === -1 ? "" : path.slice(at + "/api/public/".length);
+}
+async function fetchOnce(config, method, url, key, body, timeoutMs, language, customerToken) {
+  const doFetch = config.fetchImpl ?? fetch;
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(),
+    Math.max(timeoutMs ?? 0, config.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+  );
+  try {
+    const response = await doFetch(url, {
+      method,
+      headers: {
+        ...key ? { "x-company-api-key": key } : {},
+        accept: "application/json",
+        ...language ? { "x-language": language } : {},
+        // Who is signed in, for the calls that take a customer — see `customerToken`.
+        ...customerToken ? { "x-customer-token": customerToken } : {},
+        ...config.productSample ? { "x-product-sample": config.productSample } : {},
+        ...config.visitor ? {
+          "x-visitor-ip": config.visitor.ip,
+          "x-api-key": config.visitor.platformKey
+        } : {},
+        ...body === void 0 ? {} : { "content-type": "application/json" }
+      },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) },
+      cache: config.cache ?? "no-store",
+      credentials: "include",
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      const { detail, ...refusal } = await refusalOf(response);
+      throw new PublicApiError(
+        String(response.status),
+        response.status,
+        detail,
+        refusal
+      );
+    }
+    if (response.status === 204) return void 0;
+    return await response.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function refusalOf(response) {
+  try {
+    const body = await response.json();
+    const message = body.message;
+    return {
+      ...refusalFactsOf(body),
+      detail: (Array.isArray(message) ? message[0] : message) ?? void 0
+    };
+  } catch {
+    return {};
+  }
+}
+function get(config, url, key) {
+  return request(config, "GET", url, key);
+}
+var COMPANY_TTL_MS = 3e4;
+function companyResolver(config) {
+  let cachedKey = null;
+  let cached = null;
+  let cachedAt = 0;
+  return function companyRecord() {
+    const key = keyFor(config);
+    if (cached && cachedKey === key && Date.now() - cachedAt < COMPANY_TTL_MS) {
+      return cached;
+    }
+    const pending = get(
+      config,
+      `${trimSlash(config.baseUrl)}/api/public/company`,
+      key
+    );
+    pending.catch(() => {
+      if (cached === pending) {
+        cached = null;
+        cachedKey = null;
+      }
+    });
+    cached = pending;
+    cachedKey = key;
+    cachedAt = Date.now();
+    return pending;
+  };
+}
+function requester(config) {
+  return async function call(resource, query = {}, timeoutMs, customerToken) {
+    return dispatch(
+      config,
+      "GET",
+      resource,
+      query,
+      void 0,
+      timeoutMs,
+      customerToken
+    );
+  };
+}
+function writer(config) {
+  return async function send(method, resource, query = {}, body, timeoutMs, customerToken) {
+    return dispatch(
+      config,
+      method,
+      resource,
+      query,
+      body,
+      timeoutMs,
+      customerToken
+    );
+  };
+}
+async function dispatch(config, method, resource, query, body, timeoutMs, customerToken) {
+  const key = keyFor(config);
+  const language = config.language === null ? void 0 : config.language ?? await resolveLanguage();
+  const search = new URLSearchParams(query).toString();
+  const base = `${trimSlash(config.baseUrl)}/api/public/${resource}`;
+  return request(
+    config,
+    method,
+    search ? `${base}?${search}` : base,
+    key,
+    body,
+    timeoutMs,
+    language,
+    customerToken ?? (config.customerToken === null ? void 0 : config.customerToken ?? resolveCustomerToken())
+  );
+}
+async function checkoutLanguage(config, wanted) {
+  const asked = typeof wanted === "string" ? wanted.trim() : "";
+  const language = asked || config.language || (config.language === null ? void 0 : await resolveLanguage());
+  return language ? { language } : {};
+}
+function quantity(value, min) {
+  const parsed = Math.floor(Number(value));
+  if (!Number.isFinite(parsed) || parsed < min) {
+    throw new Error("invalid quantity");
+  }
+  return Math.min(parsed, MAX_QUANTITY);
+}
+function customerEmail(value) {
+  if (value === void 0 || value === null || value === "") return {};
+  const raw = typeof value === "string" ? value.trim() : "";
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(raw) || raw.length > 320) {
+    throw new Error("invalid customerEmail");
+  }
+  return { customerEmail: raw };
+}
+function trackQuery(params) {
+  const checkoutId = typeof params?.checkoutId === "string" ? params.checkoutId.trim() : "";
+  if (checkoutId) return { checkoutId: segment(checkoutId, "checkoutId") };
+  const code = typeof params?.code === "string" ? params.code.trim() : "";
+  if (!code || code.length > 16) throw new Error("invalid code");
+  let email;
+  try {
+    email = customerEmail(params?.email).customerEmail;
+  } catch {
+    email = void 0;
+  }
+  if (!email) throw new Error("invalid email");
+  return { code, email };
+}
+function pick(value) {
+  return {
+    slotId: segment(value?.slotId, "slotId"),
+    productId: segment(value?.productId, "productId"),
+    ...value?.variantId ? { variantId: segment(value.variantId, "variantId") } : {},
+    ...typeof value?.variant === "string" ? { variant: value.variant } : {}
+  };
+}
+function returnUrl(key, value) {
+  if (value === void 0 || value === null || value === "") return {};
+  if (typeof value !== "string" || !/^https?:\/\/\S+$/.test(value)) {
+    throw new Error(`invalid ${key}`);
+  }
+  return { [key]: value };
+}
+function token(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  return requiredToken(value);
+}
+function requiredToken(value) {
+  if (typeof value !== "string" || !value.trim() || value.length > 4096 || /\s/.test(value.trim())) {
+    throw new Error("invalid customerToken");
+  }
+  return value.trim();
+}
+function requiredEmail(value) {
+  const email = customerEmail(value).customerEmail;
+  if (!email) throw new Error("invalid email");
+  return email;
+}
+function signInCode(value) {
+  const code = String(value ?? "").replace(/\s/g, "");
+  if (!/^\d{6}$/.test(code)) throw new Error("invalid code");
+  return code;
+}
+function textOf(value, name, max) {
+  if (typeof value !== "string" || !value.trim() || value.length > max) {
+    throw new Error(`invalid ${name}`);
+  }
+  return value.trim();
+}
+function voteValue(value, allowZero) {
+  const vote = Number(value);
+  if (!Number.isInteger(vote) || vote < -1 || vote > 10 || vote === 0 && !allowZero) {
+    throw new Error("invalid vote");
+  }
+  return vote;
+}
+function historyQuery(page, limit) {
+  return {
+    ...whole("page", page, 1, 1e5),
+    ...whole("limit", limit, 1, 50)
+  };
+}
+
+export {
+  createPublicApiClient
+};
+//# sourceMappingURL=chunk-5DN7L6LX.js.map