@tagadapay/headless-sdk 1.14.0 → 1.16.0

package/dist/tagada-headless.js

@@ -1,5 +1,5 @@
 /**
- * @tagadapay/headless-sdk v1.14.0
+ * @tagadapay/headless-sdk v1.16.0
  * Headless checkout, payments, offers, and CRM
  * @license MIT
  */
@@ -63,6 +63,7 @@ var TagadaHeadlessBundle = (() => {
     TagadaPaymentError: () => TagadaPaymentError,
     TagadaRateLimitError: () => TagadaRateLimitError,
     TagadaValidationError: () => TagadaValidationError,
+    TrackModule: () => TrackModule,
     createHeadlessClient: () => createHeadlessClient,
     ensureGeoDataLoaded: () => ensureGeoDataLoaded,
     formatMoney: () => formatMoney,
@@ -237,10 +238,11 @@ var TagadaHeadlessBundle = (() => {
 
   // src/core/modules/checkout.ts
   var CheckoutModule = class _CheckoutModule {
-    constructor(http, storeId, onTokenChange) {
+    constructor(http, storeId, onTokenChange, onSession) {
       this.http = http;
       this.storeId = storeId;
       this.onTokenChange = onTokenChange;
+      this.onSession = onSession;
     }
     /**
      * Returns the most recently loaded `CheckoutSession`, if any.
@@ -264,7 +266,7 @@ var TagadaHeadlessBundle = (() => {
      * Example URL: `/checkout?checkoutToken=abc123&token=eyJ...`
      */
     async loadSession(checkoutToken, sessionToken, opts) {
-      var _a;
+      var _a, _b;
       if (sessionToken) {
         this.sessionToken = sessionToken;
         (_a = this.onTokenChange) == null ? void 0 : _a.call(this, sessionToken);
@@ -282,6 +284,10 @@ var TagadaHeadlessBundle = (() => {
       );
       const session = this.normalizeSession(raw);
       this._currentSession = session;
+      try {
+        (_b = this.onSession) == null ? void 0 : _b.call(this, session);
+      } catch {
+      }
       return session;
     }
     /**
@@ -359,16 +365,9 @@ var TagadaHeadlessBundle = (() => {
      * ```
      */
     async createSessionUrl(opts) {
-      const session = await this.createSession({
-        items: opts.items,
-        currency: opts.currency,
-        returnUrl: opts.returnUrl,
-        customerEmail: opts.customerEmail,
-        customerFirstName: opts.customerFirstName,
-        customerLastName: opts.customerLastName
-      });
-      const origin = opts.origin ?? (typeof window !== "undefined" ? window.location.origin : "");
-      const checkoutPath = opts.checkoutPath ?? "/checkout";
+      const { checkoutPath = "/checkout", origin: originOverride, ...sessionOpts } = opts;
+      const session = await this.createSession(sessionOpts);
+      const origin = originOverride ?? (typeof window !== "undefined" ? window.location.origin : "");
       const params = new URLSearchParams({
         checkoutToken: session.checkoutToken,
         sessionToken: session.sessionToken
@@ -758,6 +757,358 @@ var TagadaHeadlessBundle = (() => {
     return Boolean(((_a = address.line1) == null ? void 0 : _a.trim()) && ((_b = address.country) == null ? void 0 : _b.trim()));
   }
 
+  // src/core/version.ts
+  var SDK_NAME = "headless";
+  var SDK_VERSION = "1.16.0";
+
+  // src/core/modules/track.ts
+  var CDN_URL = false ? "" : "https://cdn.jsdelivr.net/npm/@tagadapay/headless-sdk@1.16.0/dist/tagada-pixels.min.js";
+  async function loadPixels() {
+    if (typeof window === "undefined")
+      return null;
+    if (CDN_URL) {
+      const w = window;
+      if (w.TagadaPixels)
+        return w.TagadaPixels;
+      await new Promise((resolve, reject) => {
+        const s = document.createElement("script");
+        s.src = CDN_URL;
+        s.async = true;
+        s.onload = () => resolve();
+        s.onerror = () => reject(new Error("pixel bundle failed to load"));
+        document.head.appendChild(s);
+      });
+      return w.TagadaPixels ?? null;
+    }
+    return await import("../../pixels/index.js");
+  }
+  var FLAG_KEY = "__tgd_track";
+  var ANON_KEY = "__tgd_aid";
+  var SESSION_KEY = "__tgd_sid";
+  var QUEUE_LIMIT = 50;
+  var FLUSH_MS = 2e3;
+  var DEDUP_MS = 1e3;
+  var STEP_MEMORY = 64;
+  function toContents(items) {
+    if (!Array.isArray(items) || items.length === 0)
+      return void 0;
+    return items.map((item) => ({ id: item.variantId, quantity: item.quantity, item_price: item.unitAmount }));
+  }
+  function scalars(data) {
+    if (!data)
+      return void 0;
+    const out = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        out[key] = value;
+    }
+    return Object.keys(out).length > 0 ? out : void 0;
+  }
+  var STANDARD_EVENTS = {
+    lead: "Lead",
+    product_viewed: "ViewContent",
+    added_to_cart: "AddToCart"
+  };
+  function uuid() {
+    try {
+      return crypto.randomUUID();
+    } catch {
+      return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+    }
+  }
+  function toPixelsConfig(pixels) {
+    const out = {};
+    for (const pixel of pixels) {
+      const { provider, id, idKey, ...rest } = pixel;
+      (out[provider] ?? (out[provider] = [])).push({ ...rest, enabled: true, [idKey]: id, events: pixel.events ?? {} });
+    }
+    return out;
+  }
+  var TrackModule = class {
+    constructor(baseUrl, storeId, funnelKey) {
+      this.baseUrl = baseUrl;
+      this.storeId = storeId;
+      this.funnelKey = funnelKey;
+      this.records = [];
+      this.lastStep = /* @__PURE__ */ new Map();
+      this.signals = [];
+      this.currentStepId = null;
+      this.manifestHash = null;
+      this.loadedProviders = [];
+      this.configPromise = null;
+      this.enginePromise = null;
+      this.flushTimer = null;
+      this.listening = false;
+    }
+    // -- opt-in flag ----------------------------------------------------------
+    /**
+     * The flag is `<storeId>:<funnelKey>`. Only the storeId half arms it; the funnel half is DATA,
+     * read back by `flagFunnelKey()` so automatic events report the funnel the last `step()` named.
+     * A funnel-key mismatch never disarms tracking; only another tenant's storeId reads as disabled.
+     */
+    flag() {
+      try {
+        return (localStorage.getItem(FLAG_KEY) ?? "").split(":");
+      } catch {
+        return [];
+      }
+    }
+    enabled() {
+      return this.flag()[0] === this.storeId;
+    }
+    flagFunnelKey() {
+      return this.flag()[1] || this.funnelKey;
+    }
+    /** Every automatic path is off under SSR and off without the flag. */
+    off() {
+      return typeof window === "undefined" || !this.enabled();
+    }
+    arm() {
+      try {
+        localStorage.setItem(FLAG_KEY, `${this.storeId}:${this.funnelKey}`);
+      } catch {
+      }
+    }
+    // -- public API -----------------------------------------------------------
+    step(stepId, data) {
+      if (typeof window === "undefined")
+        return;
+      this.arm();
+      const path = (data == null ? void 0 : data.path) ?? window.location.pathname;
+      const key = `${stepId}|${path}`;
+      const at = Date.now();
+      const previous = this.lastStep.get(key);
+      if (previous !== void 0 && at - previous < DEDUP_MS)
+        return;
+      this.remember(key, at);
+      this.currentStepId = stepId;
+      this.listen();
+      this.push({ kind: "step", stepId, at, path });
+      void this.pixels().then((engine) => engine == null ? void 0 : engine.pageView(path, { stepId }));
+    }
+    event(name, data) {
+      if (this.off())
+        return;
+      const stepId = this.currentStepId;
+      if (stepId === null)
+        return;
+      const standard = STANDARD_EVENTS[name];
+      const eventId = `${standard ?? name}_${uuid()}`;
+      this.push({ kind: "event", stepId, name, at: Date.now(), eventId, props: scalars(data) });
+      void this.pixels().then(
+        (engine) => standard ? engine == null ? void 0 : engine.track(standard, data, { stepId, eventId }) : engine == null ? void 0 : engine.trackCustom(name, data, { stepId })
+      );
+    }
+    /** Keep the dedup map to entries still inside the window, and never past `STEP_MEMORY`. */
+    remember(key, at) {
+      for (const [seen, when] of this.lastStep) {
+        if (at - when >= DEDUP_MS)
+          this.lastStep.delete(seen);
+      }
+      while (this.lastStep.size >= STEP_MEMORY) {
+        const oldest = this.lastStep.keys().next();
+        if (oldest.done === true)
+          break;
+        this.lastStep.delete(oldest.value);
+      }
+      this.lastStep.set(key, at);
+    }
+    identify(who) {
+      if (this.off())
+        return;
+      void this.pixels().then(
+        (engine) => engine == null ? void 0 : engine.identify({ email: who.email, phone: who.phone, externalId: who.customerId })
+      );
+    }
+    consent(state) {
+      if (this.off())
+        return;
+      void this.pixels().then((engine) => engine == null ? void 0 : engine.consent(state));
+    }
+    async health() {
+      if (typeof window === "undefined")
+        return this.snapshot();
+      if (this.enabled())
+        await this.config();
+      return this.snapshot();
+    }
+    // -- internal hooks, called by the checkout and payment modules -----------
+    /** @internal */
+    noteCheckout(input) {
+      this.notePixel("InitiateCheckout", input.checkoutSessionId, input);
+    }
+    /** @internal */
+    notePaid(input) {
+      this.notePixel("Purchase", input.orderId, input);
+    }
+    /** The `eventId` formula is the server's `makeMetaEventId`, so Meta and TikTok dedup. */
+    notePixel(event, id, input) {
+      if (this.off())
+        return;
+      void this.pixels().then(
+        (engine) => {
+          var _a;
+          return engine == null ? void 0 : engine.track(
+            event,
+            { value: input.amount, currency: input.currency, contents: input.items, num_items: (_a = input.items) == null ? void 0 : _a.length },
+            { eventId: `${event}_${id}` }
+          );
+        }
+      );
+    }
+    /** @internal */
+    noteSignal(signal, value, detail) {
+      if (this.off())
+        return;
+      this.signals.push({ signal, value, detail });
+      this.listen();
+      this.push({ kind: "signal", signal, value, detail });
+    }
+    // -- config, engine -------------------------------------------------------
+    snapshot() {
+      return {
+        enabled: typeof window === "undefined" ? false : this.enabled(),
+        storeId: this.storeId,
+        funnelKey: this.flagFunnelKey(),
+        sdk: { name: SDK_NAME, version: SDK_VERSION },
+        manifestHash: this.manifestHash,
+        pixels: { loaded: this.loadedProviders.length > 0, providers: [...this.loadedProviders] },
+        signals: [...this.signals]
+      };
+    }
+    /**
+     * R4, once per page. Plain `fetch`, no header, no credentials — never `HttpClient`,
+     * which adds `Content-Type` and `x-cms-token` and so preflights against a fixed allow-list.
+     */
+    config() {
+      if (this.configPromise !== null)
+        return this.configPromise;
+      const url = `${this.baseUrl}/api/public/v1/sdk/config?storeId=${encodeURIComponent(this.storeId)}&funnel=${encodeURIComponent(this.flagFunnelKey())}`;
+      this.configPromise = (async () => {
+        try {
+          const response = await fetch(url);
+          if (!response.ok)
+            return null;
+          const config = await response.json();
+          this.manifestHash = config.manifestHash || null;
+          return config;
+        } catch {
+          return null;
+        }
+      })();
+      return this.configPromise;
+    }
+    pixels() {
+      if (!this.enabled())
+        return Promise.resolve(null);
+      this.enginePromise ?? (this.enginePromise = this.startEngine());
+      return this.enginePromise;
+    }
+    async startEngine() {
+      var _a;
+      try {
+        const config = await this.config();
+        if (config === null)
+          return null;
+        const module = await loadPixels();
+        if (module === null)
+          return null;
+        const engine = module.createPixelEngine({
+          pixels: toPixelsConfig(config.pixels ?? []),
+          steps: config.steps,
+          checkout: config.checkout,
+          requireConsent: ((_a = config.consent) == null ? void 0 : _a.required) === true,
+          onSignal: (signal) => this.onPixelSignal(signal)
+        });
+        await engine.init();
+        this.loadedProviders = [...new Set((config.pixels ?? []).map((pixel) => pixel.provider))];
+        return engine;
+      } catch {
+        return null;
+      }
+    }
+    onPixelSignal(signal) {
+      const detail = signal.detail ?? {};
+      this.signals.push({ signal: signal.kind, value: signal.provider, detail });
+      this.push({ kind: "signal", signal: signal.kind, value: signal.provider, detail });
+    }
+    // -- R5 queue -------------------------------------------------------------
+    listen() {
+      if (this.listening || typeof window === "undefined")
+        return;
+      this.listening = true;
+      const onLeave = (event) => {
+        if (event.type === "visibilitychange" && document.visibilityState !== "hidden")
+          return;
+        this.flush();
+      };
+      window.addEventListener("pagehide", onLeave);
+      window.addEventListener("visibilitychange", onLeave);
+    }
+    push(record) {
+      if (!this.enabled())
+        return;
+      this.records.push(record);
+      if (this.records.length >= QUEUE_LIMIT) {
+        this.flush();
+        return;
+      }
+      if (this.flushTimer === null)
+        this.flushTimer = setTimeout(() => this.flush(), FLUSH_MS);
+    }
+    /** `localStorage` is an undeclared identifier in Node, so it is read inside the try. */
+    identifier(scope, key) {
+      try {
+        const store = scope === "local" ? localStorage : sessionStorage;
+        const existing = store.getItem(key);
+        if (existing)
+          return existing;
+        const fresh = uuid();
+        store.setItem(key, fresh);
+        return fresh;
+      } catch {
+        return uuid();
+      }
+    }
+    flush() {
+      if (this.flushTimer !== null) {
+        clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+      }
+      if (this.records.length === 0)
+        return;
+      const records = this.records.splice(0, QUEUE_LIMIT);
+      const payload = {
+        storeId: this.storeId,
+        funnelKey: this.flagFunnelKey(),
+        sdk: { name: SDK_NAME, version: SDK_VERSION },
+        anonymousId: this.identifier("local", ANON_KEY),
+        sessionId: this.identifier("session", SESSION_KEY),
+        records
+      };
+      if (this.manifestHash !== null)
+        payload.manifestHash = this.manifestHash;
+      const body = JSON.stringify(payload);
+      const url = `${this.baseUrl}/api/public/v1/sdk/events`;
+      try {
+        if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
+          if (navigator.sendBeacon(url, new Blob([body], { type: "text/plain;charset=UTF-8" })))
+            return;
+        }
+      } catch {
+      }
+      try {
+        void fetch(url, {
+          method: "POST",
+          body,
+          keepalive: true,
+          headers: { "content-type": "text/plain;charset=UTF-8" }
+        }).catch(() => void 0);
+      } catch {
+      }
+    }
+  };
+
   // src/core/modules/payment.ts
   var EXPRESS_METHOD_TYPES = /* @__PURE__ */ new Set(["apple_pay", "google_pay", "paypal", "klarna", "klarna_express", "link"]);
   function paymentMethodListEntryToConfig(entry) {
@@ -782,11 +1133,13 @@ var TagadaHeadlessBundle = (() => {
     };
   }
   var PaymentModule = class {
-    constructor(http, storeId, environment, checkout) {
+    constructor(http, storeId, environment, checkout, onPaid, onSignal) {
       this.http = http;
       this.storeId = storeId;
       this.environment = environment;
       this.checkout = checkout;
+      this.onPaid = onPaid;
+      this.onSignal = onSignal;
       /**
        * Last payment setup seen by `getPaymentSetup` — lets `processApplePay`
        * resolve the domain's Apple Pay registration (BYOK / platform-integrator)
@@ -854,7 +1207,7 @@ var TagadaHeadlessBundle = (() => {
      * filtered to only those available in the current browser.
      */
     async getExpressMethods(checkoutSessionId, opts) {
-      var _a, _b, _c, _d, _e, _f, _g, _h;
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
       const setup = await this.getPaymentSetup(checkoutSessionId, opts);
       const result = {};
       for (const [key, config] of Object.entries(setup)) {
@@ -872,12 +1225,15 @@ var TagadaHeadlessBundle = (() => {
             result.applePay = { ...base2, type: "apple_pay", available: !!hasApplePay };
           }
           if ((_d = config.methods.google_pay) == null ? void 0 : _d.enabled) {
+            if (typeof window !== "undefined" && !("PaymentRequest" in window)) {
+              (_e = this.onSignal) == null ? void 0 : _e.call(this, "googlePay", { reason: "no-payment-request-api" });
+            }
             result.googlePay = { ...base2, type: "google_pay" };
           }
-          if ((_e = config.methods.link) == null ? void 0 : _e.enabled) {
+          if ((_f = config.methods.link) == null ? void 0 : _f.enabled) {
             result.link = { ...base2, type: "link" };
           }
-          if ((_f = config.methods.klarna_express) == null ? void 0 : _f.enabled) {
+          if ((_g = config.methods.klarna_express) == null ? void 0 : _g.enabled) {
             result.klarna = { ...base2, type: "klarna_express" };
           }
           continue;
@@ -893,9 +1249,12 @@ var TagadaHeadlessBundle = (() => {
           metadata: config.metadata
         };
         if (method === "apple_pay" || config.type === "apple_pay") {
-          const hasApplePay = typeof window !== "undefined" && "ApplePaySession" in window && ((_h = (_g = window.ApplePaySession) == null ? void 0 : _g.canMakePayments) == null ? void 0 : _h.call(_g));
+          const hasApplePay = typeof window !== "undefined" && "ApplePaySession" in window && ((_i = (_h = window.ApplePaySession) == null ? void 0 : _h.canMakePayments) == null ? void 0 : _i.call(_h));
           result.applePay = { ...base, available: !!hasApplePay };
         } else if (method === "google_pay" || config.type === "google_pay") {
+          if (typeof window !== "undefined" && !("PaymentRequest" in window)) {
+            (_j = this.onSignal) == null ? void 0 : _j.call(this, "googlePay", { reason: "no-payment-request-api" });
+          }
           result.googlePay = base;
         } else if (method === "paypal") {
           result.paypal = base;
@@ -1294,14 +1653,15 @@ var TagadaHeadlessBundle = (() => {
      * don't need to re-pay.
      */
     async finalize(input, opts) {
-      var _a, _b;
+      var _a, _b, _c;
       const payment = input.payment;
       const returnUrl = (opts == null ? void 0 : opts.returnUrl) ?? (typeof window !== "undefined" ? window.location.href : void 0);
       if (payment.status === "succeeded") {
+        this.emitPaid((_a = input.order) == null ? void 0 : _a.id, payment);
         return { status: "succeeded", payment, order: input.order };
       }
       if (payment.status === "failed" || payment.status === "declined") {
-        const msg = ((_a = payment.requireActionData) == null ? void 0 : _a.message) || ((_b = payment.requireActionData) == null ? void 0 : _b.errorCode) || `Payment ${payment.status}`;
+        const msg = ((_b = payment.requireActionData) == null ? void 0 : _b.message) || ((_c = payment.requireActionData) == null ? void 0 : _c.errorCode) || `Payment ${payment.status}`;
         return { status: "failed", error: msg, payment };
       }
       if (payment.requireAction && payment.requireAction !== "none" && payment.requireActionData) {
@@ -1535,6 +1895,7 @@ var TagadaHeadlessBundle = (() => {
      * Also handles new requireAction that may appear during polling.
      */
     async pollUntilDone(paymentId, opts) {
+      var _a;
       const interval = (opts == null ? void 0 : opts.intervalMs) ?? 1500;
       const timeout = (opts == null ? void 0 : opts.timeoutMs) ?? 6e4;
       const start = Date.now();
@@ -1553,6 +1914,9 @@ var TagadaHeadlessBundle = (() => {
           continue;
         }
         if (status.status === "succeeded" || status.status === "pending" && status.subStatus === "authorized") {
+          if (status.status === "succeeded") {
+            this.emitPaid((_a = status.order) == null ? void 0 : _a.id, status);
+          }
           return { status: "succeeded", payment: status, order: status.order };
         }
         if (status.status === "failed" || status.status === "declined") {
@@ -1588,14 +1952,32 @@ var TagadaHeadlessBundle = (() => {
         return null;
       }
     }
+    /** Tracking hook. Never throws, never awaits: a pixel must not be able to break a payment. */
+    emitPaid(orderId, payment) {
+      var _a;
+      if (!orderId || !this.onPaid)
+        return;
+      try {
+        const session = (_a = this.checkout) == null ? void 0 : _a.getCurrentSession();
+        this.onPaid({
+          orderId,
+          amount: payment.amount,
+          currency: payment.currency,
+          items: toContents(session == null ? void 0 : session.items)
+        });
+      } catch {
+      }
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async loadCoreJs() {
       try {
         return await import("@tagadapay/core-js");
-      } catch {
-        throw new Error(
+      } catch (cause) {
+        const error = new Error(
           "This method requires @tagadapay/core-js. Install it: npm install @tagadapay/core-js"
         );
+        error.cause = cause;
+        throw error;
       }
     }
   };
@@ -2029,8 +2411,24 @@ var TagadaHeadlessBundle = (() => {
 
   // src/core/modules/rx.ts
   var RxModule = class {
-    constructor(http) {
+    constructor(http, storeId) {
       this.http = http;
+      this.storeId = storeId;
+    }
+    /**
+     * Activation status of the store: steps, missing items and whether Rx
+     * payments are `setting_up` or `ready`. Storefronts use it to show
+     * "Payments are being set up" instead of letting a checkout fail.
+     *
+     * Read-only / public. Defaults to the client's `storeId`.
+     */
+    async getActivationStatus(storeId) {
+      const id = storeId ?? this.storeId;
+      if (!id)
+        throw new Error("rx.getActivationStatus: storeId is required");
+      return this.http.get("/api/public/v1/rx/activation-status", {
+        params: { storeId: id }
+      });
     }
     /**
      * Check whether a product requires an Rx case. Storefronts call this
@@ -2094,11 +2492,29 @@ var TagadaHeadlessBundle = (() => {
         apiKey: config.apiKey,
         getToken: () => this._sessionToken
       });
+      this.track = new TrackModule(baseUrl, this.config.storeId, this.config.funnel ?? "main");
       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.checkout);
+      this.checkout = new CheckoutModule(
+        this.http,
+        this.config.storeId,
+        setToken,
+        (s) => this.track.noteCheckout({
+          checkoutSessionId: s.id,
+          amount: s.totals.total,
+          currency: s.totals.currency,
+          items: toContents(s.items)
+        })
+      );
+      this.payment = new PaymentModule(
+        this.http,
+        this.config.storeId,
+        environment,
+        this.checkout,
+        (p) => this.track.notePaid(p),
+        (v, d) => this.track.noteSignal("wallet_unavailable", v, d)
+      );
       this.offers = new OffersModule(this.http, this.config.storeId, this.payment);
       this.customer = new CustomerModule(this.http, this.config.storeId);
       this.catalog = new CatalogModule(this.http, this.config.storeId);
@@ -2108,7 +2524,7 @@ var TagadaHeadlessBundle = (() => {
         this.checkout,
         this.config.accountId
       );
-      this.rx = new RxModule(this.http);
+      this.rx = new RxModule(this.http, this.config.storeId);
     }
     /** Manually set the session token (e.g. from URL params on page load). */
     setSessionToken(token) {