@tagadapay/headless-sdk 1.0.0

package/dist/tagada-headless.js

@@ -0,0 +1,1093 @@
+/**
+ * @tagadapay/headless-sdk v1.0.0
+ * Headless checkout, payments, analytics, and CRM
+ * @license MIT
+ */
+"use strict";
+var TagadaHeadlessBundle = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/core/index.ts
+  var core_exports = {};
+  __export(core_exports, {
+    AnalyticsModule: () => AnalyticsModule,
+    CheckoutModule: () => CheckoutModule,
+    CustomerModule: () => CustomerModule,
+    HeadlessClient: () => HeadlessClient,
+    HttpClient: () => HttpClient,
+    OffersModule: () => OffersModule,
+    PaymentModule: () => PaymentModule,
+    TagadaAuthError: () => TagadaAuthError,
+    TagadaError: () => TagadaError,
+    TagadaNetworkError: () => TagadaNetworkError,
+    TagadaNotFoundError: () => TagadaNotFoundError,
+    TagadaPaymentError: () => TagadaPaymentError,
+    TagadaRateLimitError: () => TagadaRateLimitError,
+    TagadaValidationError: () => TagadaValidationError,
+    createHeadlessClient: () => createHeadlessClient
+  });
+
+  // src/core/errors.ts
+  var TagadaError = class extends Error {
+    constructor(message, code, statusCode, details) {
+      super(message);
+      this.name = "TagadaError";
+      this.code = code;
+      this.statusCode = statusCode;
+      this.details = details;
+    }
+  };
+  var TagadaAuthError = class extends TagadaError {
+    constructor(message = "Authentication failed. Check your API key or checkout token.") {
+      super(message, "auth_error", 401);
+      this.name = "TagadaAuthError";
+    }
+  };
+  var TagadaValidationError = class extends TagadaError {
+    constructor(message, errors = []) {
+      super(message, "validation_error", 422, { errors });
+      this.name = "TagadaValidationError";
+      this.errors = errors;
+    }
+  };
+  var TagadaNotFoundError = class extends TagadaError {
+    constructor(resource, id) {
+      super(`${resource} "${id}" not found.`, "not_found", 404);
+      this.name = "TagadaNotFoundError";
+    }
+  };
+  var TagadaRateLimitError = class extends TagadaError {
+    constructor(retryAfterMs = 1e3) {
+      super(`Rate limited. Retry after ${retryAfterMs}ms.`, "rate_limit", 429);
+      this.name = "TagadaRateLimitError";
+      this.retryAfterMs = retryAfterMs;
+    }
+  };
+  var TagadaPaymentError = class extends TagadaError {
+    constructor(message, opts) {
+      super(message, "payment_error", void 0, opts == null ? void 0 : opts.details);
+      this.name = "TagadaPaymentError";
+      this.paymentId = opts == null ? void 0 : opts.paymentId;
+      this.requireAction = opts == null ? void 0 : opts.requireAction;
+    }
+  };
+  var TagadaNetworkError = class extends TagadaError {
+    constructor(message = "Network request failed. Check your connection.") {
+      super(message, "network_error");
+      this.name = "TagadaNetworkError";
+    }
+  };
+
+  // src/core/http.ts
+  var BASE_URLS = {
+    production: "https://app.tagadapay.com",
+    development: "https://app.dev.tagadapay.com",
+    local: "http://localhost:3000"
+  };
+  var HttpClient = class {
+    constructor(config) {
+      this.baseUrl = config.baseUrl.replace(/\/$/, "");
+      this.timeout = config.timeout;
+      this.apiKey = config.apiKey;
+      this.getToken = config.getToken;
+    }
+    static resolveBaseUrl(environment, override) {
+      return override ?? BASE_URLS[environment] ?? BASE_URLS.production;
+    }
+    async request(path, options = {}) {
+      var _a;
+      const { method = "GET", body, headers = {}, params, token, signal } = options;
+      let url = `${this.baseUrl}${path}`;
+      if (params) {
+        const qs = new URLSearchParams();
+        for (const [k, v] of Object.entries(params)) {
+          if (v !== void 0)
+            qs.set(k, String(v));
+        }
+        const str = qs.toString();
+        if (str)
+          url += `?${str}`;
+      }
+      const reqHeaders = {
+        "Content-Type": "application/json",
+        ...headers
+      };
+      const authToken = token ?? this.apiKey ?? ((_a = this.getToken) == null ? void 0 : _a.call(this));
+      if (authToken) {
+        reqHeaders["x-cms-token"] = authToken;
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const res = await fetch(url, {
+          method,
+          headers: reqHeaders,
+          body: body != null ? JSON.stringify(body) : void 0,
+          signal: signal ?? controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (res.ok) {
+          const text = await res.text();
+          return text ? JSON.parse(text) : {};
+        }
+        await this.handleErrorResponse(res, path);
+        throw new TagadaError("Unexpected error", "unknown", res.status);
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof TagadaError)
+          throw err;
+        if (err instanceof DOMException && err.name === "AbortError") {
+          throw new TagadaNetworkError(`Request to ${path} timed out after ${this.timeout}ms.`);
+        }
+        throw new TagadaNetworkError(
+          err instanceof Error ? err.message : "Network request failed."
+        );
+      }
+    }
+    get(path, options) {
+      return this.request(path, { ...options, method: "GET" });
+    }
+    post(path, body, options) {
+      return this.request(path, { ...options, method: "POST", body });
+    }
+    patch(path, body, options) {
+      return this.request(path, { ...options, method: "PATCH", body });
+    }
+    put(path, body, options) {
+      return this.request(path, { ...options, method: "PUT", body });
+    }
+    delete(path, options) {
+      return this.request(path, { ...options, method: "DELETE" });
+    }
+    async handleErrorResponse(res, path) {
+      let parsed = {};
+      try {
+        parsed = await res.json();
+      } catch {
+      }
+      const msg = parsed.message ?? parsed.error ?? `Request failed: ${res.status} ${res.statusText} on ${path}`;
+      switch (res.status) {
+        case 401:
+        case 403:
+          throw new TagadaAuthError(msg);
+        case 404:
+          throw new TagadaNotFoundError(path, "");
+        case 422: {
+          const fieldErrors = Array.isArray(parsed.errors) ? parsed.errors : [];
+          throw new TagadaValidationError(msg, fieldErrors);
+        }
+        case 429: {
+          const retryAfter = Number(res.headers.get("Retry-After") ?? "1") * 1e3;
+          throw new TagadaRateLimitError(retryAfter);
+        }
+        default:
+          throw new TagadaError(msg, "api_error", res.status, parsed);
+      }
+    }
+  };
+
+  // src/core/modules/checkout.ts
+  var CheckoutModule = class {
+    constructor(http, storeId, onTokenChange) {
+      this.http = http;
+      this.storeId = storeId;
+      this.onTokenChange = onTokenChange;
+    }
+    /**
+     * Load an existing checkout session by its checkout token.
+     *
+     * @param checkoutToken The checkout token (from URL param `checkoutToken`).
+     * @param sessionToken The JWT session token (from URL param `token`). Required for auth.
+     *
+     * Both values come from the redirect URL returned by `createSession()`.
+     * Example URL: `/checkout?checkoutToken=abc123&token=eyJ...`
+     */
+    async loadSession(checkoutToken, sessionToken) {
+      var _a;
+      if (sessionToken) {
+        this.sessionToken = sessionToken;
+        (_a = this.onTokenChange) == null ? void 0 : _a.call(this, sessionToken);
+      }
+      const raw = await this.http.get(
+        `/api/v1/checkout-sessions/${checkoutToken}/v2`,
+        {
+          params: { skipAsyncWait: "false" },
+          token: this.sessionToken
+        }
+      );
+      return this.normalizeSession(raw);
+    }
+    /**
+     * Create a new checkout session.
+     *
+     * Returns a `checkoutToken` and `sessionToken` (JWT) needed for all subsequent calls.
+     * Also returns a `checkoutUrl` (the full Tagada-hosted checkout URL, for reference).
+     */
+    async createSession(opts) {
+      var _a;
+      const lineItems = opts.items.map((i) => ({
+        variantId: i.variantId,
+        priceId: i.priceId,
+        quantity: i.quantity
+      }));
+      const body = {
+        storeId: this.storeId,
+        lineItems
+      };
+      if (opts.currency)
+        body.currency = opts.currency;
+      if (opts.returnUrl)
+        body.returnUrl = opts.returnUrl;
+      if (opts.customerEmail) {
+        body.customer = {
+          email: opts.customerEmail,
+          firstName: opts.customerFirstName,
+          lastName: opts.customerLastName,
+          currency: opts.currency
+        };
+      }
+      const res = await this.http.post("/api/v1/checkout/session/init", body);
+      const url = new URL(res.checkoutUrl);
+      const sessionToken = url.searchParams.get("token") ?? "";
+      this.sessionToken = sessionToken;
+      if (sessionToken)
+        (_a = this.onTokenChange) == null ? void 0 : _a.call(this, sessionToken);
+      return {
+        checkoutUrl: res.checkoutUrl,
+        checkoutToken: res.checkoutToken,
+        sessionToken,
+        customerId: res.customerId
+      };
+    }
+    /** Replace the cart items for an existing session. */
+    async updateCart(sessionId, items) {
+      return this.http.post(
+        `/api/v1/checkout-sessions/${sessionId}/items`,
+        { items },
+        { token: this.sessionToken }
+      );
+    }
+    /** Update customer information on the session. */
+    async updateCustomer(sessionId, customer) {
+      return this.http.patch(
+        `/api/v1/checkout-sessions/${sessionId}/customer`,
+        { data: customer },
+        { token: this.sessionToken }
+      );
+    }
+    /** Update shipping and/or billing address on the session. */
+    async updateAddress(sessionId, addresses) {
+      return this.http.post(
+        `/api/v1/checkout-sessions/${sessionId}/address`,
+        { data: addresses },
+        { token: this.sessionToken }
+      );
+    }
+    /** Apply a promotion code to the session. */
+    async applyPromoCode(sessionId, code) {
+      return this.http.post(
+        `/api/v1/checkout-sessions/${sessionId}/promo`,
+        { code },
+        { token: this.sessionToken }
+      );
+    }
+    /** Remove the currently applied promotion code. */
+    async removePromoCode(sessionId) {
+      return this.http.delete(`/api/v1/checkout-sessions/${sessionId}/promo`, {
+        token: this.sessionToken
+      });
+    }
+    /** Fetch available shipping rates for the session's address. */
+    async getShippingRates(sessionId) {
+      const res = await this.http.get(
+        `/api/v1/checkout-sessions/${sessionId}/shipping-rates`,
+        { token: this.sessionToken }
+      );
+      return res.rates;
+    }
+    /** Select a shipping rate for the session. */
+    async selectShippingRate(sessionId, rateId) {
+      return this.http.post(
+        `/api/v1/checkout-sessions/${sessionId}/shipping-rates`,
+        { rateId },
+        { token: this.sessionToken }
+      );
+    }
+    /**
+     * Normalize the raw v2 API response into a cleaner CheckoutSession shape.
+     * The raw response has nested `checkoutSession` + `summary` -- we flatten it.
+     */
+    normalizeSession(raw) {
+      const cs = raw.checkoutSession;
+      const orderSummaries = cs.orderSummaries ?? [];
+      const summary = raw.summary ?? cs.summary ?? orderSummaries[0] ?? {};
+      const lineItems = cs.sessionLineItems ?? [];
+      const customer = cs.customer;
+      const items = lineItems.map((li) => {
+        const price = li.price;
+        const variant = (price == null ? void 0 : price.variant) ?? {};
+        const product = variant.product ?? {};
+        const currencyOpts = (price == null ? void 0 : price.currencyOptions) ?? {};
+        const usd = currencyOpts.USD ?? currencyOpts[Object.keys(currencyOpts)[0]];
+        return {
+          id: li.id,
+          variantId: li.variantId,
+          priceId: li.priceId,
+          productName: product.name ?? "",
+          variantName: variant.name ?? "",
+          quantity: li.quantity ?? 1,
+          unitAmount: (usd == null ? void 0 : usd.amount) ?? 0,
+          totalAmount: ((usd == null ? void 0 : usd.amount) ?? 0) * (li.quantity ?? 1),
+          currency: cs.selectedPresentmentCurrency ?? "USD",
+          imageUrl: variant.imageUrl ?? ""
+        };
+      });
+      const summaryItems = summary.items ?? [];
+      return {
+        id: cs.id,
+        storeId: cs.storeId,
+        checkoutToken: cs.checkoutToken,
+        currency: cs.selectedPresentmentCurrency ?? "USD",
+        items,
+        totals: {
+          subtotal: summary.subtotalAmount ?? 0,
+          discount: summary.totalPromotionAmount ?? 0,
+          shipping: summary.shippingCost ?? 0,
+          tax: summary.totalTaxAmount ?? 0,
+          total: summary.totalAmount ?? summaryItems.reduce((s, i) => s + (i.amount ?? 0), 0),
+          currency: summary.currency ?? cs.selectedPresentmentCurrency ?? "USD"
+        },
+        customer: customer ? {
+          id: customer.id,
+          email: customer.email,
+          firstName: customer.firstName,
+          lastName: customer.lastName
+        } : void 0,
+        shippingAddress: cs.shippingAddress,
+        billingAddress: cs.billingAddress,
+        metadata: cs.metadata
+      };
+    }
+  };
+
+  // src/core/modules/payment.ts
+  var PaymentModule = class {
+    constructor(http, storeId, environment) {
+      this.http = http;
+      this.storeId = storeId;
+      this.environment = environment;
+    }
+    // ---------------------------------------------------------------------------
+    // Discovery: what payment methods are available?
+    // ---------------------------------------------------------------------------
+    /**
+     * Get the full payment setup config for a checkout session.
+     * Returns a map of payment methods with their configuration
+     * (card, apple_pay, google_pay, klarna, etc.).
+     */
+    async getPaymentSetup(checkoutSessionId) {
+      const methods = await this.http.get(
+        "/api/v1/payment-methods",
+        { params: { checkoutSessionId } }
+      );
+      const config = {};
+      for (const m of methods.methods ?? []) {
+        const key = m.provider ? `${m.method}:${m.provider}` : m.method;
+        config[key] = m;
+      }
+      return config;
+    }
+    /**
+     * Get express payment methods (Apple Pay, Google Pay, PayPal, etc.)
+     * filtered to only those available in the current browser.
+     */
+    async getExpressMethods(checkoutSessionId) {
+      var _a, _b;
+      const setup = await this.getPaymentSetup(checkoutSessionId);
+      const result = {};
+      for (const [, config] of Object.entries(setup)) {
+        if (!config.enabled || !config.express)
+          continue;
+        const method = config.method;
+        const base = {
+          type: method,
+          available: true,
+          processorId: config.processorId,
+          publishableKey: config.publishableKey,
+          metadata: config.metadata
+        };
+        if (method === "apple_pay" || config.type === "apple_pay") {
+          const hasApplePay = typeof window !== "undefined" && "ApplePaySession" in window && ((_b = (_a = window.ApplePaySession) == null ? void 0 : _a.canMakePayments) == null ? void 0 : _b.call(_a));
+          result.applePay = { ...base, available: !!hasApplePay };
+        } else if (method === "google_pay" || config.type === "google_pay") {
+          result.googlePay = base;
+        } else if (method === "paypal") {
+          result.paypal = base;
+        } else if (method === "klarna" || method === "klarna_express") {
+          result.klarna = base;
+        } else if (method === "link") {
+          result.link = base;
+        }
+      }
+      return result;
+    }
+    /**
+     * Get store-level payment config (3DS flags, default flow ID, etc.).
+     */
+    async getStoreConfig() {
+      const res = await this.http.get(
+        "/api/v1/checkout/config",
+        { params: { storeId: this.storeId } }
+      );
+      return res.config ?? res;
+    }
+    /**
+     * Convenience: return only enabled payment method keys.
+     */
+    async getEnabledMethods(checkoutSessionId) {
+      const setup = await this.getPaymentSetup(checkoutSessionId);
+      return Object.entries(setup).filter(([, c]) => c.enabled).map(([key]) => key);
+    }
+    // ---------------------------------------------------------------------------
+    // Tokenization (delegates to @tagadapay/core-js if available)
+    // ---------------------------------------------------------------------------
+    /**
+     * Tokenize a card using @tagadapay/core-js.
+     * Requires `@tagadapay/core-js` to be installed as a peer dependency.
+     *
+     * @returns tagadaToken (base64 string) and rawToken with SCA metadata.
+     */
+    async tokenizeCard(card) {
+      const coreJs = await this.loadCoreJs();
+      const tokenizer = new coreJs.Tokenizer({ environment: this.environment });
+      await tokenizer.initialize();
+      const sanitized = {
+        cardNumber: card.cardNumber,
+        expiryDate: card.expiryDate,
+        cvc: card.cvc
+      };
+      if (card.cardholderName)
+        sanitized.cardholderName = card.cardholderName;
+      const [tagadaToken, rawToken] = await Promise.all([
+        tokenizer.tokenizeCard(sanitized),
+        tokenizer.tokenizeCardRaw(sanitized)
+      ]);
+      return { tagadaToken, rawToken };
+    }
+    // ---------------------------------------------------------------------------
+    // Instrument creation
+    // ---------------------------------------------------------------------------
+    /**
+     * Create a reusable payment instrument from a TagadaToken.
+     * Session-authenticated (uses the checkout session JWT).
+     */
+    async createInstrument(opts) {
+      return this.http.post("/api/v1/payment/create-instrument-from-token", {
+        tagadaToken: opts.tagadaToken
+      });
+    }
+    // ---------------------------------------------------------------------------
+    // 3DS
+    // ---------------------------------------------------------------------------
+    /**
+     * Create a 3DS session on the TagadaPay backend.
+     * This persists the session so the processor can use it during payment.
+     */
+    async create3dsSession(opts) {
+      return this.http.post("/api/public/v1/threeds/create-session", {
+        provider: opts.provider ?? "basis_theory",
+        storeId: this.storeId,
+        paymentInstrumentId: opts.paymentInstrumentId,
+        sessionData: opts.sessionData
+      });
+    }
+    // ---------------------------------------------------------------------------
+    // Payment processing
+    // ---------------------------------------------------------------------------
+    /**
+     * High-level pay: single API call that decodes tagadaToken server-side,
+     * creates the payment instrument, and processes payment.
+     *
+     * Also accepts `paymentInstrumentId` directly for pre-created instruments.
+     */
+    async pay(opts) {
+      if (opts.tagadaToken && !opts.paymentInstrumentId) {
+        return this.http.post("/api/v1/payment/pay-with-token", {
+          tagadaToken: opts.tagadaToken,
+          checkoutSessionId: opts.checkoutSessionId,
+          paymentFlowId: opts.paymentFlowId,
+          processorId: opts.processorId,
+          paymentMethod: opts.paymentMethod,
+          isExpress: opts.isExpress,
+          metadata: opts.metadata
+        });
+      }
+      return this.http.post("/api/public/v1/checkout/pay-v2", {
+        checkoutSessionId: opts.checkoutSessionId,
+        paymentInstrumentId: opts.paymentInstrumentId,
+        storeId: this.storeId,
+        paymentFlowId: opts.paymentFlowId,
+        threedsSessionId: opts.threedsSessionId,
+        processorId: opts.processorId,
+        paymentMethod: opts.paymentMethod,
+        isExpress: opts.isExpress,
+        metadata: opts.metadata
+      });
+    }
+    /**
+     * Low-level pay: process payment with an existing instrument or for APM/express flows
+     * where no instrument is needed (redirect-based methods).
+     */
+    async payDirect(opts) {
+      return this.http.post("/api/public/v1/checkout/pay-v2", {
+        checkoutSessionId: opts.checkoutSessionId,
+        paymentInstrumentId: opts.paymentInstrumentId ?? "",
+        storeId: this.storeId,
+        paymentFlowId: opts.paymentFlowId,
+        processorId: opts.processorId,
+        paymentMethod: opts.paymentMethod,
+        isExpress: opts.isExpress,
+        threedsSessionId: opts.threedsSessionId
+      });
+    }
+    /**
+     * Process an Apple Pay payment.
+     * Tokenizes the Apple Pay token and processes payment in one call.
+     */
+    async processApplePay(opts) {
+      const coreJs = await this.loadCoreJs();
+      const tokenizer = new coreJs.Tokenizer({ environment: this.environment });
+      await tokenizer.initialize();
+      const { tagadaToken } = await tokenizer.tokenizeApplePay(opts.applePayToken);
+      return this.pay({
+        checkoutSessionId: opts.checkoutSessionId,
+        tagadaToken,
+        paymentFlowId: opts.paymentFlowId,
+        processorId: opts.processorId,
+        paymentMethod: "apple_pay",
+        isExpress: true
+      });
+    }
+    /**
+     * Process a Google Pay payment.
+     * Tokenizes the Google Pay token and processes payment in one call.
+     */
+    async processGooglePay(opts) {
+      const coreJs = await this.loadCoreJs();
+      const tokenizer = new coreJs.Tokenizer({ environment: this.environment });
+      await tokenizer.initialize();
+      const { tagadaToken } = await tokenizer.tokenizeGooglePay(opts.googlePayToken);
+      return this.pay({
+        checkoutSessionId: opts.checkoutSessionId,
+        tagadaToken,
+        paymentFlowId: opts.paymentFlowId,
+        processorId: opts.processorId,
+        paymentMethod: "google_pay",
+        isExpress: true
+      });
+    }
+    /**
+     * Process an APM payment (Klarna, iDEAL, etc.) via redirect.
+     * These typically don't require a payment instrument -- the processor handles the redirect.
+     */
+    async processApm(opts) {
+      return this.payDirect({
+        checkoutSessionId: opts.checkoutSessionId,
+        paymentMethod: opts.paymentMethod,
+        processorId: opts.processorId,
+        paymentFlowId: opts.paymentFlowId
+      });
+    }
+    // ---------------------------------------------------------------------------
+    // Status polling
+    // ---------------------------------------------------------------------------
+    /** Get current status of a payment. */
+    async getPaymentStatus(paymentId) {
+      return this.http.get(`/api/v1/payments/${paymentId}`);
+    }
+    /**
+     * Poll a payment until it reaches a terminal status.
+     * Returns the final status or throws on timeout.
+     */
+    async pollPaymentStatus(paymentId, opts) {
+      const interval = (opts == null ? void 0 : opts.intervalMs) ?? 1500;
+      const timeout = (opts == null ? void 0 : opts.timeoutMs) ?? 6e4;
+      const start = Date.now();
+      while (Date.now() - start < timeout) {
+        const status = await this.getPaymentStatus(paymentId);
+        if (status.status === "succeeded" || status.status === "failed" || status.status === "declined") {
+          return status;
+        }
+        await new Promise((r) => setTimeout(r, interval));
+      }
+      throw new Error(`Payment ${paymentId} did not reach terminal status within ${timeout}ms.`);
+    }
+    /** Finalize a payment after a 3DS challenge completes. */
+    async completeAfter3ds(paymentId) {
+      return this.http.post("/api/v1/payments/complete-after-3ds", {
+        paymentId
+      });
+    }
+    // ---------------------------------------------------------------------------
+    // Internal helpers
+    // ---------------------------------------------------------------------------
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async loadCoreJs() {
+      try {
+        return await import("@tagadapay/core-js");
+      } catch {
+        throw new Error(
+          "This method requires @tagadapay/core-js. Install it: npm install @tagadapay/core-js"
+        );
+      }
+    }
+  };
+
+  // src/core/modules/analytics.ts
+  var AnalyticsModule = class {
+    constructor(http, storeId) {
+      this.http = http;
+      this.storeId = storeId;
+      this.pixels = { loaded: false };
+      this.eventQueue = [];
+      this.dedupeSet = /* @__PURE__ */ new Set();
+    }
+    /**
+     * Initialize analytics by loading pixel configuration from the store.
+     * Call this once on page load. Events fired before init completes are queued.
+     */
+    async init(opts) {
+      if (this.pixels.loaded)
+        return;
+      let config = opts == null ? void 0 : opts.pixelConfig;
+      if (!config) {
+        try {
+          const res = await this.http.get(
+            "/api/v1/checkout/config",
+            { params: { storeId: this.storeId } }
+          );
+          config = res.pixels;
+        } catch {
+        }
+      }
+      this.pixels = { loaded: true, config };
+      if (typeof window !== "undefined" && config) {
+        this.loadPixelScripts(config);
+      }
+      this.flushQueue();
+    }
+    // ---------------------------------------------------------------------------
+    // Standard e-commerce events
+    // ---------------------------------------------------------------------------
+    trackPageView(page) {
+      this.fireEvent("PageView", { page: page ?? this.getCurrentPath() });
+    }
+    trackViewContent(data) {
+      this.fireEvent("ViewContent", data);
+    }
+    trackAddToCart(data) {
+      this.fireEvent("AddToCart", data);
+    }
+    trackInitiateCheckout(data) {
+      this.fireEvent("InitiateCheckout", data ?? {});
+    }
+    trackAddPaymentInfo(data) {
+      this.fireEvent("AddPaymentInfo", data ?? {});
+    }
+    trackPurchase(data) {
+      this.fireEvent("Purchase", data, true);
+    }
+    trackCustomEvent(event, data) {
+      this.fireEvent(event, data ?? {});
+    }
+    /** Track a funnel step (maps to Tagada's funnel tracking endpoint). */
+    trackStep(data) {
+      this.fireEvent("FunnelStep", data);
+      this.http.post("/api/v1/funnel-tracking/step", {
+        storeId: this.storeId,
+        ...data
+      }).catch(() => {
+      });
+    }
+    trackConversion(data) {
+      this.fireEvent("Conversion", data, true);
+    }
+    // ---------------------------------------------------------------------------
+    // Internals
+    // ---------------------------------------------------------------------------
+    fireEvent(event, data, dedupe = false) {
+      if (dedupe) {
+        const key = `${event}:${JSON.stringify(data)}`;
+        if (this.dedupeSet.has(key))
+          return;
+        this.dedupeSet.add(key);
+      }
+      if (!this.pixels.loaded) {
+        this.eventQueue.push({ event, data });
+        return;
+      }
+      this.sendToMeta(event, data);
+      this.sendToTikTok(event, data);
+      this.sendToSnapchat(event, data);
+      this.sendToGTM(event, data);
+      this.sendToGA(event, data);
+    }
+    flushQueue() {
+      const queue = [...this.eventQueue];
+      this.eventQueue = [];
+      for (const { event, data } of queue) {
+        this.fireEvent(event, data);
+      }
+    }
+    getCurrentPath() {
+      return typeof window !== "undefined" ? window.location.pathname : "/";
+    }
+    // ---------------------------------------------------------------------------
+    // Pixel script loaders
+    // ---------------------------------------------------------------------------
+    loadPixelScripts(config) {
+      if (config.metaPixelId)
+        this.loadMetaPixel(config.metaPixelId);
+      if (config.tiktokPixelId)
+        this.loadTikTokPixel(config.tiktokPixelId);
+      if (config.snapchatPixelId)
+        this.loadSnapchatPixel(config.snapchatPixelId);
+      if (config.gtmId)
+        this.loadGTM(config.gtmId);
+      if (config.gaId)
+        this.loadGA(config.gaId);
+    }
+    loadMetaPixel(pixelId) {
+      if (typeof window === "undefined")
+        return;
+      const w = window;
+      if (w.fbq)
+        return;
+      const n = w.fbq = function(...args) {
+        n.callMethod ? n.callMethod(...args) : n.queue.push(args);
+      };
+      n.queue = [];
+      n.loaded = true;
+      n.version = "2.0";
+      this.injectScript("https://connect.facebook.net/en_US/fbevents.js");
+      w.fbq("init", pixelId);
+    }
+    loadTikTokPixel(pixelId) {
+      if (typeof window === "undefined")
+        return;
+      const w = window;
+      if (w.ttq)
+        return;
+      const ttq = {};
+      ttq.methods = ["page", "track", "identify", "instances", "debug", "on", "off", "once", "ready", "alias", "group", "enableCookie", "disableCookie"];
+      ttq.setAndDefer = function(t, e) {
+        t[e] = function(...args) {
+          t.push([e, ...args]);
+        };
+      };
+      w.ttq = ttq;
+      this.injectScript("https://analytics.tiktok.com/i18n/pixel/events.js?sdkid=" + pixelId);
+    }
+    loadSnapchatPixel(pixelId) {
+      if (typeof window === "undefined")
+        return;
+      const w = window;
+      if (w.snaptr)
+        return;
+      w.snaptr = function(...args) {
+        w.snaptr.handleRequest ? w.snaptr.handleRequest(...args) : w.snaptr.queue.push(args);
+      };
+      w.snaptr.queue = [];
+      this.injectScript("https://sc-static.net/scevent.min.js");
+      w.snaptr("init", pixelId);
+    }
+    loadGTM(gtmId) {
+      if (typeof window === "undefined")
+        return;
+      const w = window;
+      w.dataLayer = w.dataLayer ?? [];
+      w.dataLayer.push({ "gtm.start": Date.now(), event: "gtm.js" });
+      this.injectScript(`https://www.googletagmanager.com/gtm.js?id=${gtmId}`);
+    }
+    loadGA(gaId) {
+      if (typeof window === "undefined")
+        return;
+      this.injectScript(`https://www.googletagmanager.com/gtag/js?id=${gaId}`);
+      const w = window;
+      w.dataLayer = w.dataLayer ?? [];
+      w.gtag = function(...args) {
+        w.dataLayer.push(args);
+      };
+      w.gtag("js", /* @__PURE__ */ new Date());
+      w.gtag("config", gaId);
+    }
+    injectScript(src) {
+      if (typeof document === "undefined")
+        return;
+      const s = document.createElement("script");
+      s.async = true;
+      s.src = src;
+      document.head.appendChild(s);
+    }
+    // ---------------------------------------------------------------------------
+    // Event dispatchers per pixel
+    // ---------------------------------------------------------------------------
+    sendToMeta(event, data) {
+      const w = typeof window !== "undefined" ? window : null;
+      const fbq = w == null ? void 0 : w.fbq;
+      if (!fbq)
+        return;
+      const metaEventMap = {
+        PageView: "PageView",
+        ViewContent: "ViewContent",
+        AddToCart: "AddToCart",
+        InitiateCheckout: "InitiateCheckout",
+        AddPaymentInfo: "AddPaymentInfo",
+        Purchase: "Purchase"
+      };
+      const mapped = metaEventMap[event];
+      if (mapped) {
+        fbq("track", mapped, data);
+      } else {
+        fbq("trackCustom", event, data);
+      }
+    }
+    sendToTikTok(event, data) {
+      var _a, _b;
+      const w = typeof window !== "undefined" ? window : null;
+      const ttq = w == null ? void 0 : w.ttq;
+      if (!ttq)
+        return;
+      if (event === "PageView") {
+        (_a = ttq.page) == null ? void 0 : _a.call(ttq);
+      } else {
+        (_b = ttq.track) == null ? void 0 : _b.call(ttq, event, data);
+      }
+    }
+    sendToSnapchat(event, data) {
+      const w = typeof window !== "undefined" ? window : null;
+      const snaptr = w == null ? void 0 : w.snaptr;
+      if (!snaptr)
+        return;
+      const snapEventMap = {
+        PageView: "PAGE_VIEW",
+        ViewContent: "VIEW_CONTENT",
+        AddToCart: "ADD_CART",
+        InitiateCheckout: "START_CHECKOUT",
+        Purchase: "PURCHASE"
+      };
+      const mapped = snapEventMap[event];
+      if (mapped)
+        snaptr("track", mapped, data);
+    }
+    sendToGTM(event, data) {
+      const w = typeof window !== "undefined" ? window : null;
+      const dataLayer = w == null ? void 0 : w.dataLayer;
+      if (!dataLayer)
+        return;
+      dataLayer.push({ event, ...data });
+    }
+    sendToGA(event, data) {
+      const w = typeof window !== "undefined" ? window : null;
+      const gtag = w == null ? void 0 : w.gtag;
+      if (!gtag)
+        return;
+      gtag("event", event, data);
+    }
+  };
+
+  // src/core/modules/offers.ts
+  var OffersModule = class {
+    constructor(http, storeId) {
+      this.http = http;
+      this.storeId = storeId;
+    }
+    /** Load offer details by ID. */
+    async loadOffer(offerId) {
+      const res = await this.http.get(
+        `/api/v1/checkout-offers/${offerId}`,
+        { params: { storeId: this.storeId } }
+      );
+      return res.offer;
+    }
+    /** List all offers for the store. */
+    async listOffers(opts) {
+      const res = await this.http.get(
+        "/api/v1/checkout-offers",
+        { params: { storeId: this.storeId, type: opts == null ? void 0 : opts.type } }
+      );
+      return res.offers;
+    }
+    /**
+     * Accept an offer (one-click upsell).
+     * Charges the stored payment instrument from the main checkout order.
+     */
+    async acceptOffer(opts) {
+      return this.http.post("/api/v1/checkout-offers/accept", {
+        offerId: opts.offerId,
+        checkoutSessionId: opts.checkoutSessionId,
+        storeId: this.storeId,
+        paymentInstrumentId: opts.paymentInstrumentId
+      });
+    }
+    /** Decline an offer. Advances the funnel to the next step. */
+    async declineOffer(opts) {
+      return this.http.post("/api/v1/checkout-offers/decline", {
+        offerId: opts.offerId,
+        checkoutSessionId: opts.checkoutSessionId,
+        storeId: this.storeId
+      });
+    }
+    /** List order bumps available for a checkout session (shown on the checkout page). */
+    async listOrderBumps(checkoutSessionId) {
+      const res = await this.http.get(
+        "/api/v1/checkout-offers",
+        { params: { storeId: this.storeId, checkoutSessionId, type: "orderbump" } }
+      );
+      return res.offers;
+    }
+    /** Toggle an order bump on/off for a checkout session. */
+    async toggleOrderBump(opts) {
+      await this.http.post(`/api/v1/checkout-sessions/${opts.checkoutSessionId}/order-bumps`, {
+        offerId: opts.offerId,
+        selected: opts.selected
+      });
+    }
+  };
+
+  // src/core/modules/customer.ts
+  var CustomerModule = class {
+    constructor(http, storeId) {
+      this.http = http;
+      this.storeId = storeId;
+    }
+    /** Get customer profile by ID. */
+    async getProfile(customerId) {
+      const res = await this.http.get(
+        `/api/v1/customers/${customerId}`,
+        { params: { storeId: this.storeId } }
+      );
+      return res.customer;
+    }
+    /** Get customer profile by email. */
+    async getByEmail(email) {
+      try {
+        const res = await this.http.get(
+          "/api/v1/customers/by-email",
+          { params: { email, storeId: this.storeId } }
+        );
+        return res.customer;
+      } catch {
+        return null;
+      }
+    }
+    /** Update customer profile fields. */
+    async updateProfile(customerId, data) {
+      const res = await this.http.patch(
+        `/api/v1/customers/${customerId}`,
+        { storeId: this.storeId, ...data }
+      );
+      return res.customer;
+    }
+    /** List orders for a customer. */
+    async getOrders(customerId, opts) {
+      return this.http.get(
+        `/api/v1/customers/${customerId}/orders`,
+        { params: { storeId: this.storeId, limit: opts == null ? void 0 : opts.limit, offset: opts == null ? void 0 : opts.offset } }
+      );
+    }
+    /** Get a single order by ID. */
+    async getOrder(orderId) {
+      const res = await this.http.get(`/api/v1/orders/${orderId}`, {
+        params: { storeId: this.storeId }
+      });
+      return res.order;
+    }
+    /** List subscriptions for a customer. */
+    async getSubscriptions(customerId) {
+      const res = await this.http.get(
+        `/api/v1/customers/${customerId}/subscriptions`,
+        { params: { storeId: this.storeId } }
+      );
+      return res.subscriptions;
+    }
+    /** Get a single subscription by ID. */
+    async getSubscription(subscriptionId) {
+      const res = await this.http.get(
+        `/api/v1/subscriptions/${subscriptionId}`,
+        { params: { storeId: this.storeId } }
+      );
+      return res.subscription;
+    }
+  };
+
+  // src/core/client.ts
+  var HeadlessClient = class {
+    constructor(config) {
+      const environment = config.environment ?? "production";
+      const baseUrl = HttpClient.resolveBaseUrl(environment, config.baseUrl);
+      this.config = {
+        ...config,
+        environment,
+        baseUrl,
+        timeout: config.timeout ?? 3e4
+      };
+      this.http = new HttpClient({
+        baseUrl,
+        timeout: this.config.timeout,
+        apiKey: config.apiKey,
+        getToken: () => this._sessionToken
+      });
+      const setToken = (token) => {
+        this._sessionToken = token;
+      };
+      this.checkout = new CheckoutModule(this.http, this.config.storeId, setToken);
+      this.payment = new PaymentModule(this.http, this.config.storeId, environment);
+      this.analytics = new AnalyticsModule(this.http, this.config.storeId);
+      this.offers = new OffersModule(this.http, this.config.storeId);
+      this.customer = new CustomerModule(this.http, this.config.storeId);
+    }
+    /** Manually set the session token (e.g. from URL params on page load). */
+    setSessionToken(token) {
+      this._sessionToken = token;
+    }
+  };
+  function createHeadlessClient(config) {
+    return new HeadlessClient(config);
+  }
+  return __toCommonJS(core_exports);
+})();
+if(typeof window!=="undefined"&&TagadaHeadlessBundle){  window.TagadaHeadless=TagadaHeadlessBundle;  window.TagadaHeadless.create=TagadaHeadlessBundle.createHeadlessClient;}