@tagadapay/headless-sdk 1.1.1 → 1.3.0

package/dist/tagada-headless.js

@@ -1,5 +1,5 @@
 /**
- * @tagadapay/headless-sdk v1.1.1
+ * @tagadapay/headless-sdk v1.3.0
  * Headless checkout, payments, analytics, and CRM
  * @license MIT
  */
@@ -43,12 +43,15 @@ var TagadaHeadlessBundle = (() => {
   // src/core/index.ts
   var core_exports = {};
   __export(core_exports, {
-    AnalyticsModule: () => AnalyticsModule,
+    AVAILABLE_LANGUAGES: () => AVAILABLE_LANGUAGES,
     CatalogModule: () => CatalogModule,
     CheckoutModule: () => CheckoutModule,
+    CurrencyUtils: () => CurrencyUtils,
     CustomerModule: () => CustomerModule,
+    GoogleAutocompleteCore: () => GoogleAutocompleteCore,
     HeadlessClient: () => HeadlessClient,
     HttpClient: () => HttpClient,
+    ISODataCore: () => ISODataCore,
     OffersModule: () => OffersModule,
     PaymentModule: () => PaymentModule,
     TagadaAuthError: () => TagadaAuthError,
@@ -58,7 +61,13 @@ var TagadaHeadlessBundle = (() => {
     TagadaPaymentError: () => TagadaPaymentError,
     TagadaRateLimitError: () => TagadaRateLimitError,
     TagadaValidationError: () => TagadaValidationError,
-    createHeadlessClient: () => createHeadlessClient
+    createHeadlessClient: () => createHeadlessClient,
+    ensureGeoDataLoaded: () => ensureGeoDataLoaded,
+    formatMoney: () => formatMoney,
+    getCountries: () => getCountries,
+    getStatesForCountry: () => getStatesForCountry,
+    isLanguageLoaded: () => isLanguageLoaded,
+    loadGoogleMapsScript: () => loadGoogleMapsScript
   });
 
   // src/core/errors.ts
@@ -717,315 +726,93 @@ var TagadaHeadlessBundle = (() => {
     }
   };
 
-  // src/core/modules/analytics.ts
-  var AnalyticsModule = class {
+  // src/core/modules/offers.ts
+  var OffersModule = 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
+    // Offer loading
     // ---------------------------------------------------------------------------
-    trackPageView(page) {
-      this.fireEvent("PageView", { page: page ?? this.getCurrentPath() });
-    }
-    trackViewContent(data) {
-      this.fireEvent("ViewContent", data);
-    }
-    trackAddToCart(data) {
-      this.fireEvent("AddToCart", data);
+    /** Get a single offer by ID. */
+    async getOffer(offerId) {
+      return this.http.get(`/api/v1/offers/${offerId}`);
     }
-    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);
+    /** List offers for the current store. Optionally filter by type or a set of IDs. */
+    async listOffers(opts) {
+      var _a;
+      let url = `/api/v1/stores/${this.storeId}/offers`;
+      const queryParts = [];
+      if (opts == null ? void 0 : opts.type)
+        queryParts.push(`type=${encodeURIComponent(opts.type)}`);
+      if ((_a = opts == null ? void 0 : opts.ids) == null ? void 0 : _a.length) {
+        for (const id of opts.ids)
+          queryParts.push(`ids=${encodeURIComponent(id)}`);
       }
-    }
-    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);
+      if (queryParts.length)
+        url += `?${queryParts.join("&")}`;
+      const res = await this.http.get(url);
+      return res.offers ?? [];
     }
     // ---------------------------------------------------------------------------
-    // Event dispatchers per pixel
+    // Preview & pay (one-click upsell flow from plugin-sdk)
     // ---------------------------------------------------------------------------
-    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;
+    /** Preview offer pricing. Returns line items with amounts and totals. */
+    async previewOffer(opts) {
+      return this.http.post(`/api/v1/offers/${opts.offerId}/preview`, {
+        offerId: opts.offerId,
+        currency: opts.currency ?? "",
+        lineItems: opts.lineItems
+      });
     }
     /**
-     * Accept an offer (one-click upsell).
-     * Charges the stored payment instrument from the main checkout order.
+     * Pay a previously previewed offer (one-click charge).
+     * Used after a main order so the stored payment instrument is reused.
      */
-    async acceptOffer(opts) {
-      return this.http.post("/api/v1/checkout-offers/accept", {
+    async payPreviewedOffer(opts) {
+      return this.http.post(`/api/v1/offers/${opts.offerId}/pay-preview`, {
         offerId: opts.offerId,
-        checkoutSessionId: opts.checkoutSessionId,
-        storeId: this.storeId,
+        currency: opts.currency ?? "",
+        lineItems: opts.lineItems,
+        returnUrl: opts.returnUrl ?? (typeof window !== "undefined" ? window.location.href : ""),
+        mainOrderId: opts.mainOrderId,
         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
-      });
+    // ---------------------------------------------------------------------------
+    // Order bumps (checkout-session scoped)
+    // ---------------------------------------------------------------------------
+    /** Toggle an order bump on/off within a checkout session. */
+    async toggleOrderBump(opts) {
+      return this.http.post(
+        `/api/v1/checkout-sessions/${opts.checkoutSessionId}/toggle-order-bump`,
+        {
+          orderBumpOfferId: opts.orderBumpOfferId,
+          selected: opts.selected
+        }
+      );
     }
-    /** 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" } }
+    // ---------------------------------------------------------------------------
+    // Post-purchase offers (order-scoped)
+    // ---------------------------------------------------------------------------
+    /** List post-purchase offers for an order. */
+    async listPostPurchaseOffers(orderId) {
+      const res = await this.http.get(`/api/v1/post-purchase/${orderId}/offers`);
+      return Array.isArray(res) ? res : [];
+    }
+    /** Accept a post-purchase offer. */
+    async acceptPostPurchaseOffer(opts) {
+      return this.http.post(
+        `/api/v1/orders/${opts.orderId}/post-purchase-offers/${opts.offerId}/accept`,
+        { items: opts.items ?? [] }
       );
-      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
-      });
+    /** Decline a post-purchase offer. */
+    async declinePostPurchaseOffer(opts) {
+      return this.http.post(
+        `/api/v1/orders/${opts.orderId}/post-purchase-offers/${opts.offerId}/decline`
+      );
     }
   };
 
@@ -1155,7 +942,6 @@ var TagadaHeadlessBundle = (() => {
       };
       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);
       this.catalog = new CatalogModule(this.http, this.config.storeId);
@@ -1168,6 +954,464 @@ var TagadaHeadlessBundle = (() => {
   function createHeadlessClient(config) {
     return new HeadlessClient(config);
   }
+
+  // src/core/helpers/autocomplete.ts
+  var scriptInjected = false;
+  var scriptReady = false;
+  var readyCallbacks = [];
+  function onScriptReady() {
+    scriptReady = true;
+    for (const cb of readyCallbacks)
+      cb();
+    readyCallbacks.length = 0;
+  }
+  function loadGoogleMapsScript(apiKey, opts = {}) {
+    var _a, _b;
+    if (scriptReady || ((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places)) {
+      onScriptReady();
+      return Promise.resolve();
+    }
+    if (scriptInjected) {
+      return new Promise((resolve) => readyCallbacks.push(resolve));
+    }
+    scriptInjected = true;
+    return new Promise((resolve, reject) => {
+      readyCallbacks.push(resolve);
+      const existing = document.querySelector('script[src*="maps.googleapis.com"]');
+      if (existing) {
+        const poll = () => {
+          var _a2, _b2;
+          if ((_b2 = (_a2 = window.google) == null ? void 0 : _a2.maps) == null ? void 0 : _b2.places) {
+            onScriptReady();
+          } else {
+            setTimeout(poll, 100);
+          }
+        };
+        poll();
+        return;
+      }
+      const params = new URLSearchParams({
+        key: apiKey,
+        libraries: "places",
+        v: opts.version ?? "weekly"
+      });
+      if (opts.language)
+        params.set("language", opts.language);
+      if (opts.region)
+        params.set("region", opts.region);
+      const script = document.createElement("script");
+      script.src = `https://maps.googleapis.com/maps/api/js?${params}`;
+      script.async = true;
+      script.defer = true;
+      script.onload = () => onScriptReady();
+      script.onerror = () => reject(new Error("Failed to load Google Maps script"));
+      document.head.appendChild(script);
+    });
+  }
+  var GoogleAutocompleteCore = class _GoogleAutocompleteCore {
+    /** Search for address predictions. */
+    static async searchPlaces(input, options = {}) {
+      var _a, _b;
+      if (!((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places) || !input.trim())
+        return [];
+      const service = new window.google.maps.places.AutocompleteService();
+      return new Promise((resolve) => {
+        service.getPlacePredictions(
+          { input, types: options.types ?? ["address"], componentRestrictions: options.componentRestrictions },
+          (predictions, status) => {
+            var _a2, _b2, _c;
+            resolve(status === ((_c = (_b2 = (_a2 = window.google) == null ? void 0 : _a2.maps) == null ? void 0 : _b2.places) == null ? void 0 : _c.PlacesServiceStatus.OK) && predictions ? predictions : []);
+          }
+        );
+      });
+    }
+    /** Get full place details by place_id. */
+    static async getPlaceDetails(placeId) {
+      var _a, _b;
+      if (!((_b = (_a = window.google) == null ? void 0 : _a.maps) == null ? void 0 : _b.places))
+        return null;
+      const svc = new window.google.maps.places.PlacesService(document.createElement("div"));
+      return new Promise((resolve) => {
+        svc.getDetails(
+          { placeId, fields: ["place_id", "formatted_address", "address_components", "geometry"] },
+          (place, status) => {
+            var _a2, _b2, _c;
+            resolve(status === ((_c = (_b2 = (_a2 = window.google) == null ? void 0 : _a2.maps) == null ? void 0 : _b2.places) == null ? void 0 : _c.PlacesServiceStatus.OK) && place ? place : null);
+          }
+        );
+      });
+    }
+    /** Extract structured address fields from a Google PlaceDetails result. */
+    static extractAddressComponents(place) {
+      const out = {
+        subpremise: "",
+        streetNumber: "",
+        route: "",
+        locality: "",
+        administrativeAreaLevel1: "",
+        administrativeAreaLevel1Long: "",
+        administrativeAreaLevel2: "",
+        administrativeAreaLevel2Long: "",
+        country: "",
+        postalCode: "",
+        fullStreetAddress: ""
+      };
+      let premise = "";
+      let neighborhood = "";
+      let sublocality5 = "", sublocality4 = "", sublocality3 = "", sublocality2 = "", sublocality1 = "";
+      let postalTown = "";
+      for (const c of place.address_components ?? []) {
+        const t = c.types;
+        if (t.includes("subpremise"))
+          out.subpremise = c.long_name;
+        if (t.includes("street_number"))
+          out.streetNumber = c.long_name;
+        if (t.includes("premise"))
+          premise = c.long_name;
+        if (t.includes("route"))
+          out.route = c.long_name;
+        if (t.includes("neighborhood"))
+          neighborhood = c.long_name;
+        if (t.includes("sublocality_level_5"))
+          sublocality5 = c.long_name;
+        if (t.includes("sublocality_level_4"))
+          sublocality4 = c.long_name;
+        if (t.includes("sublocality_level_3"))
+          sublocality3 = c.long_name;
+        if (t.includes("sublocality_level_2"))
+          sublocality2 = c.long_name;
+        if (t.includes("sublocality_level_1"))
+          sublocality1 = c.long_name;
+        if (t.includes("locality"))
+          out.locality = c.long_name;
+        if (t.includes("postal_town"))
+          postalTown = c.long_name;
+        if (t.includes("administrative_area_level_2")) {
+          out.administrativeAreaLevel2 = c.short_name;
+          out.administrativeAreaLevel2Long = c.long_name;
+        }
+        if (t.includes("administrative_area_level_1")) {
+          out.administrativeAreaLevel1 = c.short_name;
+          out.administrativeAreaLevel1Long = c.long_name;
+        }
+        if (t.includes("country"))
+          out.country = c.short_name;
+        if (t.includes("postal_code"))
+          out.postalCode = c.long_name;
+      }
+      if (!out.locality)
+        out.locality = postalTown || sublocality2 || sublocality1 || "";
+      if (!out.administrativeAreaLevel1 && out.administrativeAreaLevel2) {
+        out.administrativeAreaLevel1 = out.administrativeAreaLevel2Long || out.administrativeAreaLevel2;
+        out.administrativeAreaLevel1Long = out.administrativeAreaLevel2Long;
+      }
+      const buildingNumber = out.streetNumber || premise;
+      const streetName = out.route || sublocality5 || sublocality4 || sublocality3 || neighborhood;
+      if (out.subpremise && buildingNumber && streetName) {
+        out.fullStreetAddress = `${out.subpremise}/${buildingNumber} ${streetName}`;
+      } else if (buildingNumber && streetName) {
+        if (premise && sublocality4 && sublocality3) {
+          let addr = `${sublocality3}-${sublocality4}-${premise}`;
+          if (sublocality2)
+            addr = `${addr} ${sublocality2}`;
+          out.fullStreetAddress = addr;
+        } else {
+          out.fullStreetAddress = `${buildingNumber} ${streetName}`;
+        }
+      } else if (streetName) {
+        out.fullStreetAddress = streetName;
+      } else if (buildingNumber) {
+        out.fullStreetAddress = buildingNumber;
+      }
+      out.fullStreetAddress = out.fullStreetAddress.trim();
+      return out;
+    }
+    /** Shorthand: extract into the flat shape used by address forms. */
+    static extractFormattedAddress(place) {
+      const a = _GoogleAutocompleteCore.extractAddressComponents(place);
+      return {
+        address1: a.fullStreetAddress,
+        city: a.locality,
+        country: a.country,
+        state: a.administrativeAreaLevel1,
+        postal: a.postalCode
+      };
+    }
+  };
+
+  // src/core/helpers/iso3166.ts
+  var GEODATA_CDN_BASE = "https://cvwnizdbugpz6jwk.public.blob.vercel-storage.com/geodata/v1";
+  var AVAILABLE_LANGUAGES = ["en", "ru", "de", "da", "fr", "es", "zh", "hi", "pt", "ja", "ar", "it", "he"];
+  var countriesCache = /* @__PURE__ */ new Map();
+  var regionsCache = /* @__PURE__ */ new Map();
+  var inflightCountries = /* @__PURE__ */ new Map();
+  var inflightRegions = /* @__PURE__ */ new Map();
+  async function fetchCountriesRaw(language) {
+    const cached = countriesCache.get(language);
+    if (cached)
+      return cached;
+    let inflight = inflightCountries.get(language);
+    if (inflight)
+      return inflight;
+    inflight = (async () => {
+      const url = `${GEODATA_CDN_BASE}/${language}/countries.json`;
+      const res = await fetch(url);
+      if (!res.ok)
+        throw new Error(`Geodata fetch failed: ${url} (${res.status})`);
+      const data = await res.json();
+      countriesCache.set(language, data);
+      inflightCountries.delete(language);
+      return data;
+    })();
+    inflightCountries.set(language, inflight);
+    return inflight;
+  }
+  async function fetchRegionsRaw(language) {
+    const cached = regionsCache.get(language);
+    if (cached)
+      return cached;
+    let inflight = inflightRegions.get(language);
+    if (inflight)
+      return inflight;
+    inflight = (async () => {
+      const url = `${GEODATA_CDN_BASE}/${language}/regions.json`;
+      const res = await fetch(url);
+      if (!res.ok)
+        throw new Error(`Geodata fetch failed: ${url} (${res.status})`);
+      const data = await res.json();
+      regionsCache.set(language, data);
+      inflightRegions.delete(language);
+      return data;
+    })();
+    inflightRegions.set(language, inflight);
+    return inflight;
+  }
+  function getCountriesCached(language) {
+    return countriesCache.get(language) || countriesCache.get("en") || {};
+  }
+  function getRegionsCached(language) {
+    return regionsCache.get(language) || regionsCache.get("en") || {};
+  }
+  async function ensureGeoDataLoaded(language = "en") {
+    await Promise.all([fetchCountriesRaw(language), fetchRegionsRaw(language)]);
+  }
+  var getCountries = (language = "en") => {
+    const raw = getCountriesCached(language);
+    return Object.entries(raw).map(([code, c]) => ({ code, name: c.n, iso3: c.i3, numeric: c.nu })).sort((a, b) => a.name.localeCompare(b.name));
+  };
+  var getStatesForCountry = (countryCode, language = "en") => {
+    const raw = getRegionsCached(language);
+    const tuples = raw[countryCode];
+    if (!tuples)
+      return [];
+    return tuples.map(([iso, name]) => ({ code: iso, name, countryCode })).sort((a, b) => a.name.localeCompare(b.name));
+  };
+  function isLanguageLoaded(language) {
+    return countriesCache.has(language);
+  }
+
+  // src/core/helpers/countries.ts
+  var ISODataCore = class _ISODataCore {
+    /** Fetch countries + regions from CDN for a language. Call before sync getters. */
+    static ensureLoaded(language = "en") {
+      return ensureGeoDataLoaded(language);
+    }
+    /** Get all countries as a Record keyed by ISO code. */
+    static getCountries(language = "en") {
+      const arr = getCountries(language);
+      const result = {};
+      for (const c of arr) {
+        result[c.code] = { iso: c.code, iso3: c.iso3 ?? "", numeric: c.numeric ?? 0, name: c.name };
+      }
+      return result;
+    }
+    /** Get all countries as a sorted array of { value, label } for select inputs. */
+    static getCountryOptions(language = "en") {
+      return getCountries(language).map((c) => ({ value: c.code, label: c.name }));
+    }
+    /** Get regions/states for a country. */
+    static getRegions(countryCode, language = "en") {
+      return getStatesForCountry(countryCode, language).map((s) => ({ iso: s.code, name: s.name }));
+    }
+    /** Get regions as a sorted array of { value, label } for select inputs. */
+    static getRegionOptions(countryCode, language = "en") {
+      return _ISODataCore.getRegions(countryCode, language).map((r) => ({ value: r.iso, label: r.name }));
+    }
+    /** Find a specific region by ISO code. */
+    static findRegion(countryCode, regionCode, language = "en") {
+      return _ISODataCore.getRegions(countryCode, language).find((r) => r.iso === regionCode) ?? null;
+    }
+    /**
+     * Map a Google Places administrative_area to an ISO region.
+     * Tries exact ISO match, then name match, then partial match.
+     */
+    static mapGoogleToISO(googleState, googleStateLong, countryCode, language = "en") {
+      const regions = _ISODataCore.getRegions(countryCode, language);
+      if (regions.length === 0)
+        return null;
+      let match = regions.find((r) => r.iso === googleState);
+      if (match)
+        return match;
+      match = regions.find((r) => r.name.toLowerCase() === googleState.toLowerCase());
+      if (match)
+        return match;
+      match = regions.find((r) => r.name.toLowerCase() === googleStateLong.toLowerCase());
+      if (match)
+        return match;
+      match = regions.find(
+        (r) => r.name.toLowerCase().includes(googleStateLong.toLowerCase()) || googleStateLong.toLowerCase().includes(r.name.toLowerCase())
+      );
+      return match ?? null;
+    }
+    static isLanguageLoaded(language) {
+      return isLanguageLoaded(language);
+    }
+    static getAvailableLanguages() {
+      return AVAILABLE_LANGUAGES;
+    }
+  };
+
+  // src/core/helpers/currency.ts
+  var SYMBOLS = {
+    USD: "$",
+    EUR: "\u20AC",
+    GBP: "\xA3",
+    JPY: "\xA5",
+    CAD: "C$",
+    AUD: "A$",
+    CHF: "CHF",
+    CNY: "\xA5",
+    SEK: "kr",
+    NOK: "kr",
+    DKK: "kr",
+    PLN: "z\u0142",
+    CZK: "K\u010D",
+    HUF: "Ft",
+    RON: "lei",
+    BGN: "\u043B\u0432",
+    HRK: "kn",
+    RUB: "\u20BD",
+    UAH: "\u20B4",
+    TRY: "\u20BA",
+    BRL: "R$",
+    MXN: "$",
+    ZAR: "R",
+    INR: "\u20B9",
+    KRW: "\u20A9",
+    THB: "\u0E3F",
+    VND: "\u20AB",
+    IDR: "Rp",
+    MYR: "RM",
+    SGD: "S$",
+    PHP: "\u20B1",
+    TWD: "NT$",
+    HKD: "HK$",
+    ILS: "\u20AA",
+    AED: "\u062F.\u0625",
+    SAR: "\u0631.\u0633",
+    QAR: "\u0631.\u0642",
+    KWD: "\u062F.\u0643",
+    BHD: "\u062F.\u0628",
+    OMR: "\u0631.\u0639.",
+    EGP: "\xA3",
+    NGN: "\u20A6",
+    KES: "KSh",
+    GHS: "\u20B5",
+    COP: "$",
+    ARS: "$",
+    CLP: "$",
+    PEN: "S/",
+    CRC: "\u20A1",
+    DOP: "RD$",
+    JMD: "J$",
+    BOB: "Bs",
+    PYG: "\u20B2",
+    GTQ: "Q",
+    NIO: "C$",
+    PAB: "B/.",
+    PKR: "\u20A8",
+    BDT: "\u09F3",
+    LKR: "\u20A8",
+    NPR: "\u20A8",
+    GEL: "\u20BE",
+    AMD: "\u058F",
+    AZN: "\u20BC",
+    KZT: "\u20B8"
+  };
+  var NAMES = {
+    USD: "US Dollar",
+    EUR: "Euro",
+    GBP: "British Pound",
+    JPY: "Japanese Yen",
+    CAD: "Canadian Dollar",
+    AUD: "Australian Dollar",
+    CHF: "Swiss Franc",
+    CNY: "Chinese Yuan",
+    SEK: "Swedish Krona",
+    NOK: "Norwegian Krone",
+    DKK: "Danish Krone",
+    PLN: "Polish Zloty",
+    CZK: "Czech Koruna",
+    HUF: "Hungarian Forint",
+    BRL: "Brazilian Real",
+    MXN: "Mexican Peso",
+    INR: "Indian Rupee",
+    KRW: "South Korean Won",
+    THB: "Thai Baht",
+    SGD: "Singapore Dollar",
+    HKD: "Hong Kong Dollar",
+    TWD: "Taiwan Dollar",
+    ILS: "Israeli Shekel",
+    AED: "UAE Dirham",
+    SAR: "Saudi Riyal",
+    ZAR: "South African Rand",
+    TRY: "Turkish Lira",
+    RUB: "Russian Ruble",
+    NGN: "Nigerian Naira"
+  };
+  var ZERO_DECIMAL = /* @__PURE__ */ new Set([
+    "JPY",
+    "KRW",
+    "VND",
+    "IDR",
+    "LAK",
+    "KHR",
+    "MMK",
+    "PYG"
+  ]);
+  var CurrencyUtils = class _CurrencyUtils {
+    static getSymbol(code) {
+      return SYMBOLS[code] ?? code;
+    }
+    static getName(code) {
+      return NAMES[code] ?? code;
+    }
+    static getDecimalPlaces(code) {
+      return ZERO_DECIMAL.has(code) ? 0 : 2;
+    }
+    static getCurrency(code) {
+      return {
+        code,
+        symbol: _CurrencyUtils.getSymbol(code),
+        name: _CurrencyUtils.getName(code),
+        decimalPlaces: _CurrencyUtils.getDecimalPlaces(code)
+      };
+    }
+  };
+  function formatMoney(amountMinorUnits, currencyCode = "USD", locale = "en-US") {
+    const decimals = CurrencyUtils.getDecimalPlaces(currencyCode);
+    const value = amountMinorUnits / (decimals === 0 ? 100 : Math.pow(10, decimals));
+    try {
+      return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency: currencyCode,
+        minimumFractionDigits: decimals,
+        maximumFractionDigits: decimals
+      }).format(value);
+    } catch {
+      return `${CurrencyUtils.getSymbol(currencyCode)}${value.toFixed(decimals)}`;
+    }
+  }
   return __toCommonJS(core_exports);
 })();
 if(typeof window!=="undefined"&&TagadaHeadlessBundle){  window.TagadaHeadless=TagadaHeadlessBundle;  window.TagadaHeadless.create=TagadaHeadlessBundle.createHeadlessClient;}