@economist/web-apple-pay 0.1.1-beta.0

package/dist/src/clients/payment-checkout/apple-session.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ApplePaySession lifecycle manager.
+ * Creates the native Apple Pay payment sheet and wires merchant validation,
+ * payment authorization, and cancellation handlers.
+ */
+export type ApplePaySessionConfig = {
+    countryCode: string;
+    currencyCode: string;
+    supportedNetworks: string[];
+    totalAmount: string;
+    totalLabel: string;
+    skuId: string;
+    returnUrl: string;
+    userLoggedIn: boolean;
+    onPaymentAuthorized: (event: ApplePayJS.ApplePayPaymentAuthorizedEvent, session: ApplePaySession) => Promise<void>;
+    onCancel?: () => void;
+};
+export declare function startApplePaySession(config: ApplePaySessionConfig): void;

package/dist/src/clients/payment-checkout/apple-session.js

@@ -0,0 +1,243 @@
+// src/clients/payment-checkout/config.ts
+var runtimeConfig = null;
+var getApplePayConfig = () => runtimeConfig;
+
+// src/clients/payment-checkout/types.ts
+var ApiError = class extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`API request failed with status ${status}`);
+    this.name = "ApiError";
+    this.status = status;
+    this.body = body;
+  }
+};
+
+// src/clients/payment-checkout/index.ts
+var getWalletApiBaseUrl = () => {
+  const config = getApplePayConfig();
+  if (!config?.walletApiBaseUrl) {
+    throw new Error(
+      "[web-apple-pay] Missing walletApiBaseUrl. Call configureApplePay({ merchantId, walletApiBaseUrl, ... }) before making wallet API requests."
+    );
+  }
+  return config.walletApiBaseUrl;
+};
+var apiFetch = async (path, options = {}) => {
+  const baseUrl = getWalletApiBaseUrl();
+  const method = (options.method ?? "GET").toUpperCase();
+  const hasBody = options.body !== void 0 && options.body !== null;
+  const headers = new Headers(options.headers);
+  if (!headers.has("Accept")) {
+    headers.set("Accept", "application/json");
+  }
+  if (!headers.has("Content-Type")) {
+    if (hasBody || method !== "GET" && method !== "HEAD") {
+      headers.set("Content-Type", "application/json");
+    }
+  }
+  const response = await fetch(`${baseUrl}${path}`, {
+    ...options,
+    headers
+  });
+  if (!response.ok) {
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      const errorBody = await response.json();
+      throw new ApiError(response.status, errorBody);
+    }
+    const errorText = await response.text();
+    throw new Error(
+      `API request failed: ${response.status} ${response.statusText} - ${errorText}`
+    );
+  }
+  return response.json();
+};
+var validateAppleMerchant = (data) => {
+  return apiFetch("/v1/wallet/validate-merchant", {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+};
+
+// src/utils/expressCheckoutRedirect.ts
+var redirectToCheckoutFallback = (params) => {
+  const url = new URL(window.location.href);
+  url.pathname = "/checkout";
+  url.searchParams.set("lmo_offer", params.skuId);
+  if (params.inlineError)
+    url.searchParams.set("inlineError", params.inlineError);
+  if (params.email) url.searchParams.set("email", params.email);
+  if (params.emailError) url.searchParams.set("emailError", params.emailError);
+  url.searchParams.set("returnUrl", params.returnUrl);
+  return url.pathname + url.search;
+};
+
+// src/utils/recaptcha.ts
+var loadRecaptchaScript = (siteKey) => {
+  return new Promise((resolve, reject) => {
+    if (typeof grecaptcha !== "undefined") return resolve();
+    const existingScript = document.querySelector(
+      'script[src*="recaptcha/api.js"]'
+    );
+    if (existingScript) {
+      existingScript.addEventListener("load", () => resolve());
+      existingScript.addEventListener(
+        "error",
+        () => reject(new Error("Failed to load existing reCAPTCHA script"))
+      );
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = `https://www.google.com/recaptcha/api.js?render=${siteKey}`;
+    script.async = true;
+    script.defer = true;
+    script.onload = () => resolve();
+    script.onerror = () => reject(new Error("Failed to load reCAPTCHA script"));
+    document.head.appendChild(script);
+  });
+};
+var getRecaptchaToken = async (action) => {
+  const siteKey = getApplePayConfig()?.recaptchaSiteKey;
+  if (!siteKey) {
+    throw new Error(
+      "[web-apple-pay] Missing recaptchaSiteKey. Call configureApplePay({ recaptchaSiteKey, ... }) before initiating Apple Pay."
+    );
+  }
+  await loadRecaptchaScript(siteKey);
+  return new Promise((resolve, reject) => {
+    grecaptcha.ready(() => {
+      grecaptcha.execute(siteKey, { action }).then(resolve).catch(reject);
+    });
+  });
+};
+
+// src/utils/expressCheckoutTracking.ts
+var EXPRESS_CHECKOUT_EVENTS = {
+  /** Wallet button displayed */
+  IMPRESSION: "express_wallet_impression",
+  /** Wallet button clicked */
+  BUTTON_CLICK: "express_wallet_click",
+  /** Apple Pay sheet opened */
+  SHEET_OPEN: "wallet_payment_sheet_open",
+  /** Payment authorised by the user in the Apple Pay sheet */
+  AUTHORISED: "wallet_payment_authorised",
+  /** Purchase completed — BFF returned success */
+  SUCCESS: "wallet_payment_success",
+  /** Payment failed — BFF returned error */
+  FAILURE: "wallet_payment_failure",
+  /** Redirect to standard checkout (any fallback path) */
+  FALLBACK_CHECKOUT: "fallback_checkout"
+};
+var emitTedlEvent = (event) => {
+  window.tedl = window.tedl ?? {};
+  window.tedl.events = window.tedl.events ?? [];
+  window.tedl.events.push(event);
+};
+var track = (action, extra) => {
+  emitTedlEvent({
+    name: "user.journey",
+    type: "checkout",
+    action,
+    info: "applepay",
+    ...extra
+  });
+};
+var trackWalletPaymentSheetOpen = (skuId) => {
+  track(EXPRESS_CHECKOUT_EVENTS.SHEET_OPEN, { sku_id: skuId });
+};
+var trackWalletPaymentAuthorised = (skuId) => {
+  track(EXPRESS_CHECKOUT_EVENTS.AUTHORISED, { sku_id: skuId });
+};
+var trackFallbackCheckout = (skuId) => {
+  track(EXPRESS_CHECKOUT_EVENTS.FALLBACK_CHECKOUT, { sku_id: skuId });
+};
+
+// src/clients/payment-checkout/messages.ts
+var MSG_PAYMENT_GENERIC_ERROR = "Something went wrong. Please check your payment and billing details and try again or contact us.";
+
+// src/clients/payment-checkout/apple-session.ts
+function startApplePaySession(config) {
+  console.log("[web-apple-pay] startApplePaySession", {
+    skuId: config.skuId,
+    countryCode: config.countryCode,
+    currencyCode: config.currencyCode,
+    totalAmount: config.totalAmount,
+    userLoggedIn: config.userLoggedIn
+  });
+  const paymentRequest = {
+    countryCode: config.countryCode,
+    currencyCode: config.currencyCode,
+    merchantCapabilities: ["supports3DS"],
+    supportedNetworks: config.supportedNetworks,
+    total: {
+      label: config.totalLabel,
+      amount: config.totalAmount
+    },
+    requiredBillingContactFields: ["postalAddress", "name"],
+    // Only request email from Apple Pay sheet if user is NOT logged in
+    ...!config.userLoggedIn && { requiredShippingContactFields: ["email"] }
+  };
+  const session = new ApplePaySession(3, paymentRequest);
+  session.onvalidatemerchant = async (event) => {
+    console.log("[web-apple-pay] onvalidatemerchant: received", { validationURL: event.validationURL });
+    try {
+      const validationHost = new URL(event.validationURL).host;
+      if (!validationHost.endsWith("apple.com")) {
+        console.warn("[web-apple-pay] onvalidatemerchant: invalid host, aborting", { validationHost });
+        trackFallbackCheckout(config.skuId);
+        session.abort();
+        window.location.href = redirectToCheckoutFallback({
+          skuId: config.skuId,
+          returnUrl: config.returnUrl,
+          inlineError: MSG_PAYMENT_GENERIC_ERROR
+        });
+        return;
+      }
+      const recaptchaToken = await getRecaptchaToken("verifyMerchant");
+      console.log("[web-apple-pay] onvalidatemerchant: calling validateAppleMerchant");
+      const response = await validateAppleMerchant({
+        validationURL: event.validationURL,
+        recaptchaToken
+      });
+      if (!response?.merchantSession) {
+        console.warn("[web-apple-pay] onvalidatemerchant: no merchantSession in response, aborting");
+        trackFallbackCheckout(config.skuId);
+        session.abort();
+        window.location.href = redirectToCheckoutFallback({
+          skuId: config.skuId,
+          returnUrl: config.returnUrl,
+          inlineError: MSG_PAYMENT_GENERIC_ERROR
+        });
+        return;
+      }
+      console.log("[web-apple-pay] onvalidatemerchant: merchant validated successfully");
+      session.completeMerchantValidation(response.merchantSession);
+    } catch (err) {
+      console.error("[web-apple-pay] onvalidatemerchant: error during validation", err);
+      trackFallbackCheckout(config.skuId);
+      session.abort();
+      window.location.href = redirectToCheckoutFallback({
+        skuId: config.skuId,
+        returnUrl: config.returnUrl,
+        inlineError: MSG_PAYMENT_GENERIC_ERROR
+      });
+    }
+  };
+  session.onpaymentauthorized = (event) => {
+    console.log("[web-apple-pay] onpaymentauthorized: payment authorized by user", { skuId: config.skuId });
+    trackWalletPaymentAuthorised(config.skuId);
+    config.onPaymentAuthorized(event, session);
+  };
+  session.oncancel = () => {
+    console.log("[web-apple-pay] oncancel: payment sheet cancelled by user", { skuId: config.skuId });
+    config.onCancel?.();
+  };
+  console.log("[web-apple-pay] startApplePaySession: beginning session");
+  trackWalletPaymentSheetOpen(config.skuId);
+  session.begin();
+}
+export {
+  startApplePaySession
+};

package/dist/src/clients/payment-checkout/billing-contact-details.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Apple Pay billing contact local validator.
+ *
+ * Validates required billing fields BEFORE sending to the BFF /v1/wallet/purchase.
+ * On validation failure, throws ContactValidationError with ApplePayError[] objects
+ * that Apple uses to highlight problematic billing fields inline — keeping the sheet open.
+ */
+export type BillingValidationResult = {
+    firstName: string;
+    lastName: string;
+};
+/**
+ * Validates the billing contact from the Apple Pay wallet.
+ *
+ * @param contact - Billing address from the Apple Pay wallet
+ * @param supportedBillingCountries - Country codes the offer supports billing to
+ * @throws {ContactValidationError} when required fields are missing — Apple Pay
+ *   sheet stays open and the first error text is shown to the user as a summary
+ * @returns firstName and lastName extracted from the contact
+ */
+export declare const billingContactDetails: (contact: ApplePayJS.ApplePayPaymentContact, supportedBillingCountries: string[]) => BillingValidationResult;

package/dist/src/clients/payment-checkout/billing-contact-details.js

@@ -0,0 +1,109 @@
+// src/utils/expressCheckoutTracking.ts
+var emitTedlEvent = (event) => {
+  window.tedl = window.tedl ?? {};
+  window.tedl.events = window.tedl.events ?? [];
+  window.tedl.events.push(event);
+};
+var track = (action, extra) => {
+  emitTedlEvent({
+    name: "user.journey",
+    type: "checkout",
+    action,
+    info: "applepay",
+    ...extra
+  });
+};
+var trackValidationFieldError = (field, errorType) => {
+  track(`validation_${field}_${errorType}`, {});
+};
+
+// src/clients/payment-checkout/messages.ts
+var MSG_MISSING_REQUIRED_FIELD = "Missing required field";
+var MSG_UNSUPPORTED_BILLING_COUNTRY = "Billing country does not match offer price zone";
+var MSG_CONTACT_VALIDATION_INTERNAL = "Could not validate Apple Pay contact";
+
+// src/clients/payment-checkout/contact-validation.ts
+var pushFieldError = (errors, billingOrShippingContact = "billing", field, errorType, errorText) => {
+  const errorCode = billingOrShippingContact === "billing" ? "billingContactInvalid" : "shippingContactInvalid";
+  errors.push(new ApplePayError(errorCode, field, errorText));
+  trackValidationFieldError(field, errorType);
+  return "";
+};
+var pushRequiredFieldError = (errors, billingOrShippingContact = "billing", field) => {
+  return pushFieldError(
+    errors,
+    billingOrShippingContact,
+    field,
+    "required",
+    MSG_MISSING_REQUIRED_FIELD
+  );
+};
+var ContactValidationError = class extends Error {
+  constructor(errors) {
+    super(MSG_CONTACT_VALIDATION_INTERNAL);
+    this.errors = errors;
+  }
+};
+
+// src/clients/payment-checkout/billing-contact-details.ts
+var countriesWithoutCityField = ["KY", "CK", "NR", "TC"];
+var countriesRequiringAllFields = ["US", "CA", "GB"];
+var resolveCountryConfig = (country) => {
+  const hasCityField = !countriesWithoutCityField.includes(country);
+  const requiresStateAndPostcode = countriesRequiringAllFields.includes(country);
+  return {
+    hasCityField,
+    requiresStateAndPostcode,
+    // if there is no city field, we require state and use it in place of city
+    requiresStateField: !hasCityField || requiresStateAndPostcode
+  };
+};
+var validateAddressFields = (errors, contact, { hasCityField, requiresStateAndPostcode, requiresStateField }) => {
+  const locality = !hasCityField ? contact.administrativeArea : contact.locality;
+  if (!contact.addressLines?.at(0)?.trim()) {
+    pushRequiredFieldError(errors, "billing", "addressLines");
+  }
+  if (!locality?.trim() && hasCityField) {
+    pushRequiredFieldError(errors, "billing", "locality");
+  }
+  if (!contact.administrativeArea?.trim() && requiresStateField) {
+    pushRequiredFieldError(errors, "billing", "administrativeArea");
+  }
+  if (!contact.postalCode?.trim() && requiresStateAndPostcode) {
+    pushRequiredFieldError(errors, "billing", "postalCode");
+  }
+};
+var validateNameFields = (errors, contact) => {
+  const firstName = contact.givenName?.trim() || "";
+  const lastName = contact.familyName?.trim() || "";
+  if (!firstName || !lastName) {
+    pushRequiredFieldError(errors, "billing", "name");
+  }
+  return { firstName, lastName };
+};
+var validateCountrySupport = (errors, country, supportedBillingCountries) => {
+  if (!supportedBillingCountries.includes(country)) {
+    pushFieldError(
+      errors,
+      "billing",
+      "countryCode",
+      "not-supported",
+      MSG_UNSUPPORTED_BILLING_COUNTRY
+    );
+  }
+};
+var billingContactDetails = (contact, supportedBillingCountries) => {
+  const errors = [];
+  const country = contact.countryCode?.toUpperCase() || pushRequiredFieldError(errors, "billing", "country");
+  const config = resolveCountryConfig(country);
+  validateAddressFields(errors, contact, config);
+  const { firstName, lastName } = validateNameFields(errors, contact);
+  validateCountrySupport(errors, country, supportedBillingCountries);
+  if (errors.length > 0) {
+    throw new ContactValidationError(errors);
+  }
+  return { firstName, lastName };
+};
+export {
+  billingContactDetails
+};

package/dist/src/clients/payment-checkout/config.d.ts

@@ -0,0 +1,9 @@
+export interface ApplePayRuntimeConfig {
+    merchantId: string;
+    recaptchaSiteKey?: string;
+    debugBypassEnabled?: boolean;
+    walletApiBaseUrl: string;
+}
+export declare const configureApplePay: (config: ApplePayRuntimeConfig) => void;
+export declare const getApplePayConfig: () => ApplePayRuntimeConfig | null;
+export declare const resetApplePayConfig: () => void;

package/dist/src/clients/payment-checkout/config.js

@@ -0,0 +1,23 @@
+// src/clients/payment-checkout/config.ts
+var runtimeConfig = null;
+var configureApplePay = (config) => {
+  console.log("[web-apple-pay] configureApplePay called", {
+    merchantId: config.merchantId,
+    walletApiBaseUrl: config.walletApiBaseUrl,
+    debugBypassEnabled: config.debugBypassEnabled,
+    recaptchaSiteKey: config.recaptchaSiteKey ? "***" : void 0
+  });
+  runtimeConfig = {
+    ...config
+  };
+};
+var getApplePayConfig = () => runtimeConfig;
+var resetApplePayConfig = () => {
+  console.log("[web-apple-pay] resetApplePayConfig called");
+  runtimeConfig = null;
+};
+export {
+  configureApplePay,
+  getApplePayConfig,
+  resetApplePayConfig
+};

package/dist/src/clients/payment-checkout/contact-validation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Apple Pay contact validation helpers.
+ * Ported from sma-checkout — helpers/contact-validation.ts
+ *
+ * pushFieldError / pushRequiredFieldError also fire TEDL analytics per field.
+ */
+import ApplePayErrorContactField = ApplePayJS.ApplePayErrorContactField;
+/**
+ * Appends an ApplePayError to the error accumulator and fires a TEDL analytics
+ * event for the failing field. Returns '' so it can be used inline with ||.
+ */
+export declare const pushFieldError: (errors: ApplePayError[], billingOrShippingContact: "billing" | "shipping" | undefined, field: ApplePayErrorContactField, errorType: "required" | "format" | "not-supported", errorText: string) => string;
+/**
+ * Convenience wrapper for required-field errors.
+ * Uses the standard 'Missing required field' message — matches sma-checkout exactly.
+ */
+export declare const pushRequiredFieldError: (errors: ApplePayError[], billingOrShippingContact: "billing" | "shipping" | undefined, field: ApplePayErrorContactField) => string;
+export declare class ContactValidationError extends Error {
+    errors: ApplePayError[];
+    constructor(errors: ApplePayError[]);
+}

package/dist/src/clients/payment-checkout/contact-validation.js

@@ -0,0 +1,50 @@
+// src/utils/expressCheckoutTracking.ts
+var emitTedlEvent = (event) => {
+  window.tedl = window.tedl ?? {};
+  window.tedl.events = window.tedl.events ?? [];
+  window.tedl.events.push(event);
+};
+var track = (action, extra) => {
+  emitTedlEvent({
+    name: "user.journey",
+    type: "checkout",
+    action,
+    info: "applepay",
+    ...extra
+  });
+};
+var trackValidationFieldError = (field, errorType) => {
+  track(`validation_${field}_${errorType}`, {});
+};
+
+// src/clients/payment-checkout/messages.ts
+var MSG_MISSING_REQUIRED_FIELD = "Missing required field";
+var MSG_CONTACT_VALIDATION_INTERNAL = "Could not validate Apple Pay contact";
+
+// src/clients/payment-checkout/contact-validation.ts
+var pushFieldError = (errors, billingOrShippingContact = "billing", field, errorType, errorText) => {
+  const errorCode = billingOrShippingContact === "billing" ? "billingContactInvalid" : "shippingContactInvalid";
+  errors.push(new ApplePayError(errorCode, field, errorText));
+  trackValidationFieldError(field, errorType);
+  return "";
+};
+var pushRequiredFieldError = (errors, billingOrShippingContact = "billing", field) => {
+  return pushFieldError(
+    errors,
+    billingOrShippingContact,
+    field,
+    "required",
+    MSG_MISSING_REQUIRED_FIELD
+  );
+};
+var ContactValidationError = class extends Error {
+  constructor(errors) {
+    super(MSG_CONTACT_VALIDATION_INTERNAL);
+    this.errors = errors;
+  }
+};
+export {
+  ContactValidationError,
+  pushFieldError,
+  pushRequiredFieldError
+};

package/dist/src/clients/payment-checkout/detects.d.ts

@@ -0,0 +1,3 @@
+export declare const isAppleDeviceOrSafari: () => boolean;
+export declare const bypassApplePayChecks: () => boolean;
+export declare const isApplePayAvailable: () => Promise<boolean>;

package/dist/src/clients/payment-checkout/detects.js

@@ -0,0 +1,56 @@
+// src/clients/payment-checkout/config.ts
+var runtimeConfig = null;
+var getApplePayConfig = () => runtimeConfig;
+
+// src/clients/payment-checkout/detects.ts
+var isAppleDeviceOrSafari = () => {
+  const isIOSOrMacTouchDevice = /iPad|iPhone|iPod/.test(navigator.userAgent) || navigator.maxTouchPoints > 1 && /Macintosh/.test(navigator.userAgent);
+  const isSafariBrowser = navigator.userAgent.indexOf("Safari") > -1 && navigator.userAgent.indexOf("Chrome") === -1;
+  return isIOSOrMacTouchDevice || isSafariBrowser;
+};
+var bypassApplePayChecks = () => new URLSearchParams(window.location.search).get("BYPASS_APPLE_PAY_CHECKS") !== null && getApplePayConfig()?.debugBypassEnabled === true;
+var isApplePayAvailable = async () => {
+  console.log("[web-apple-pay] isApplePayAvailable: checking availability");
+  if (bypassApplePayChecks()) {
+    console.log("[web-apple-pay] isApplePayAvailable: bypass active \u2192 true");
+    return true;
+  }
+  if (!isAppleDeviceOrSafari()) {
+    console.log("[web-apple-pay] isApplePayAvailable: not Apple device or Safari \u2192 false");
+    return false;
+  }
+  const applePaySession = window.ApplePaySession;
+  if (!applePaySession) {
+    console.log("[web-apple-pay] isApplePayAvailable: ApplePaySession not found on window \u2192 false");
+    return false;
+  }
+  try {
+    if (typeof applePaySession.canMakePayments !== "function") {
+      console.log("[web-apple-pay] isApplePayAvailable: canMakePayments is not a function \u2192 false");
+      return false;
+    }
+    if (!applePaySession.canMakePayments()) {
+      console.log("[web-apple-pay] isApplePayAvailable: canMakePayments() returned false \u2192 false");
+      return false;
+    }
+    const merchantId = getApplePayConfig()?.merchantId;
+    if (!merchantId) {
+      console.warn(
+        "[web-apple-pay] Missing merchantId. Call configureApplePay({ merchantId, ... }) before rendering Apple Pay components."
+      );
+      return false;
+    }
+    console.log("[web-apple-pay] isApplePayAvailable : calling canMakePaymentsWithActiveCard", { merchantId });
+    const result = await applePaySession.canMakePaymentsWithActiveCard(merchantId);
+    console.log("[web-apple-pay] isApplePayAvailable: canMakePaymentsWithActiveCard \u2192", result);
+    return result;
+  } catch (error) {
+    console.error("Error checking Apple Pay active card status:", error);
+    return false;
+  }
+};
+export {
+  bypassApplePayChecks,
+  isAppleDeviceOrSafari,
+  isApplePayAvailable
+};

package/dist/src/clients/payment-checkout/index.d.ts

@@ -0,0 +1,5 @@
+import type { PaymentOptionsRequest, PaymentOptionsResponse, PurchaseRequest, PurchaseResponse, ValidateMerchantRequest, ValidateMerchantResponse } from './types';
+export declare const apiFetch: <T>(path: string, options?: RequestInit) => Promise<T>;
+export declare const getPaymentOptions: (data: PaymentOptionsRequest) => Promise<PaymentOptionsResponse>;
+export declare const validateAppleMerchant: (data: ValidateMerchantRequest) => Promise<ValidateMerchantResponse>;
+export declare const performPurchase: (data: PurchaseRequest) => Promise<PurchaseResponse>;

package/dist/src/clients/payment-checkout/index.js

@@ -0,0 +1,83 @@
+// src/clients/payment-checkout/config.ts
+var runtimeConfig = null;
+var getApplePayConfig = () => runtimeConfig;
+
+// src/clients/payment-checkout/types.ts
+var ApiError = class extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`API request failed with status ${status}`);
+    this.name = "ApiError";
+    this.status = status;
+    this.body = body;
+  }
+};
+
+// src/clients/payment-checkout/index.ts
+var getWalletApiBaseUrl = () => {
+  const config = getApplePayConfig();
+  if (!config?.walletApiBaseUrl) {
+    throw new Error(
+      "[web-apple-pay] Missing walletApiBaseUrl. Call configureApplePay({ merchantId, walletApiBaseUrl, ... }) before making wallet API requests."
+    );
+  }
+  return config.walletApiBaseUrl;
+};
+var apiFetch = async (path, options = {}) => {
+  const baseUrl = getWalletApiBaseUrl();
+  const method = (options.method ?? "GET").toUpperCase();
+  const hasBody = options.body !== void 0 && options.body !== null;
+  const headers = new Headers(options.headers);
+  if (!headers.has("Accept")) {
+    headers.set("Accept", "application/json");
+  }
+  if (!headers.has("Content-Type")) {
+    if (hasBody || method !== "GET" && method !== "HEAD") {
+      headers.set("Content-Type", "application/json");
+    }
+  }
+  const response = await fetch(`${baseUrl}${path}`, {
+    ...options,
+    headers
+  });
+  if (!response.ok) {
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      const errorBody = await response.json();
+      throw new ApiError(response.status, errorBody);
+    }
+    const errorText = await response.text();
+    throw new Error(
+      `API request failed: ${response.status} ${response.statusText} - ${errorText}`
+    );
+  }
+  return response.json();
+};
+var getPaymentOptions = (data) => {
+  const { sku, countryCode, currencyCode, checkoutUrl } = data;
+  const params = new URLSearchParams({ checkoutUrl });
+  return apiFetch(
+    `/v1/wallet/payment-options/sku/${sku}/${countryCode}/${currencyCode}?${params}`,
+    { method: "GET" }
+  );
+};
+var validateAppleMerchant = (data) => {
+  return apiFetch("/v1/wallet/validate-merchant", {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+};
+var performPurchase = (data) => {
+  return apiFetch("/v1/wallet/purchase", {
+    method: "POST",
+    body: JSON.stringify(data),
+    credentials: "include"
+  });
+};
+export {
+  apiFetch,
+  getPaymentOptions,
+  performPurchase,
+  validateAppleMerchant
+};