@tiquo/dom-package 1.5.1 → 1.5.3

package/dist/index.mjs

@@ -641,8 +641,258 @@ function printTiquoBranding() {
   }
 }
 printTiquoBranding();
+var ANALYTICS_LOCATION_EVENT = "tiquo:locationchange";
+var analyticsHistoryPatched = false;
+function randomId() {
+  try {
+    if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+      return crypto.randomUUID();
+    }
+  } catch {
+  }
+  return `ev_${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
+}
+function normalizeHostname(hostname) {
+  if (!hostname) return void 0;
+  const clean = hostname.trim().toLowerCase().split(":")[0];
+  return clean.startsWith("www.") ? clean.slice(4) : clean;
+}
+function getBrowser() {
+  if (typeof navigator === "undefined") return "Other";
+  const ua = navigator.userAgent;
+  if (/Edg(e|A|iOS)?\//i.test(ua)) return "Edge";
+  if (/Firefox\//i.test(ua)) return "Firefox";
+  if (/Chrome\/|CriOS\//i.test(ua)) return "Chrome";
+  if (/Safari\//i.test(ua) && !/Chrome/i.test(ua)) return "Safari";
+  return "Other";
+}
+function getDevice() {
+  if (typeof navigator === "undefined") return "Desktop";
+  const ua = navigator.userAgent;
+  if (/iPad|tablet|PlayBook|Silk/i.test(ua)) return "Tablet";
+  if (/Android(?!.*Mobile)/i.test(ua) && /Android/i.test(ua) && !/Mobile/i.test(ua))
+    return "Tablet";
+  if (/Mobile|iPhone|iPod|Android.*Mobile|webOS|BlackBerry|Opera Mini|IEMobile/i.test(
+    ua
+  ))
+    return "Mobile";
+  return "Desktop";
+}
+function getOperatingSystem() {
+  if (typeof navigator === "undefined") return "Other";
+  const ua = navigator.userAgent;
+  if (/iPhone|iPad|iPod/i.test(ua)) return "iOS";
+  if (/Android/i.test(ua)) return "Android";
+  if (/CrOS/i.test(ua)) return "Chrome OS";
+  if (/Windows/i.test(ua)) return "Windows";
+  if (/Macintosh|Mac OS X/i.test(ua)) return "macOS";
+  if (/Linux/i.test(ua)) return "Linux";
+  return "Other";
+}
+function getUtmParams() {
+  if (typeof window === "undefined") return {};
+  const params = new URLSearchParams(window.location.search);
+  return {
+    source: params.get("utm_source") || void 0,
+    medium: params.get("utm_medium") || void 0,
+    campaign: params.get("utm_campaign") || void 0,
+    content: params.get("utm_content") || void 0,
+    term: params.get("utm_term") || void 0
+  };
+}
+function patchHistoryForAnalytics() {
+  if (analyticsHistoryPatched || typeof window === "undefined") return;
+  analyticsHistoryPatched = true;
+  const notify = () => {
+    window.dispatchEvent(
+      new Event(ANALYTICS_LOCATION_EVENT)
+    );
+  };
+  const pushState = history.pushState;
+  history.pushState = function patchedPushState(...args) {
+    const result = pushState.apply(this, args);
+    notify();
+    return result;
+  };
+  const replaceState = history.replaceState;
+  history.replaceState = function patchedReplaceState(...args) {
+    const result = replaceState.apply(this, args);
+    notify();
+    return result;
+  };
+  window.addEventListener("popstate", notify);
+}
+var _TiquoAnalytics = class _TiquoAnalytics {
+  constructor(config) {
+    this.pageStartedAt = Date.now();
+    this.lastPath = null;
+    this.started = false;
+    if (!config.publicKey) {
+      throw new TiquoAuthError("publicKey is required", "MISSING_PUBLIC_KEY");
+    }
+    if (!config.publicKey.startsWith("pk_dom_")) {
+      throw new TiquoAuthError(
+        "Invalid public key format. Expected pk_dom_xxx",
+        "INVALID_PUBLIC_KEY"
+      );
+    }
+    this.config = {
+      publicKey: config.publicKey,
+      apiEndpoint: config.apiEndpoint || "https://edge.tiquo.app",
+      debug: config.debug || false,
+      autoTrackPageviews: config.autoTrackPageviews !== false,
+      getAccessToken: config.getAccessToken,
+      siteSlug: config.siteSlug
+    };
+    this.clientSessionId = this.getClientSessionId();
+    if (this.config.autoTrackPageviews) {
+      this.start();
+    }
+  }
+  start() {
+    if (this.started || typeof window === "undefined") return;
+    const activeKey = `${this.config.publicKey}:${this.config.siteSlug || ""}`;
+    const existing = _TiquoAnalytics.activeInstances.get(activeKey);
+    if (existing && existing !== this) {
+      existing.adoptConfig(this.config);
+      return;
+    }
+    _TiquoAnalytics.activeInstances.set(activeKey, this);
+    this.started = true;
+    patchHistoryForAnalytics();
+    this.trackPageview();
+    window.addEventListener(
+      ANALYTICS_LOCATION_EVENT,
+      () => this.trackPageview()
+    );
+    window.addEventListener("pagehide", () => this.trackEngagement());
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") this.trackEngagement();
+    });
+  }
+  async trackPageview(options = {}) {
+    if (typeof window === "undefined") return;
+    const path = options.path || `${window.location.pathname}${window.location.search}`;
+    if (path === this.lastPath) return;
+    if (this.lastPath) {
+      this.trackEngagement().catch(() => void 0);
+    }
+    this.lastPath = path;
+    this.pageStartedAt = Date.now();
+    await this.track("pageview", {
+      ...options,
+      path,
+      url: options.url || window.location.href,
+      title: options.title || document.title,
+      referrer: options.referrer || document.referrer || void 0
+    });
+  }
+  async track(eventType, options = {}) {
+    if (typeof window === "undefined") return;
+    const utm = getUtmParams();
+    const payload = {
+      publicKey: this.config.publicKey,
+      eventId: randomId(),
+      eventType,
+      eventName: options.eventName,
+      eventProperties: options.eventProperties,
+      clientSessionId: this.clientSessionId,
+      siteSlug: options.siteSlug || this.config.siteSlug,
+      pageSlug: options.pageSlug,
+      hostname: normalizeHostname(window.location.hostname),
+      path: options.path || `${window.location.pathname}${window.location.search}`,
+      url: options.url || window.location.href,
+      title: options.title || document.title,
+      referrer: options.referrer || document.referrer || void 0,
+      timestamp: Date.now(),
+      browser: getBrowser(),
+      device: getDevice(),
+      operatingSystem: getOperatingSystem(),
+      language: navigator.language,
+      screenWidth: window.screen?.width,
+      screenHeight: window.screen?.height,
+      viewportWidth: window.innerWidth,
+      viewportHeight: window.innerHeight,
+      durationMs: options.durationMs,
+      scrollDepth: options.scrollDepth,
+      identityLinkType: options.identityLinkType,
+      ...utm
+    };
+    await this.send(payload);
+  }
+  async identify(options = {}) {
+    await this.track("identify", {
+      ...options,
+      identityLinkType: options.identityLinkType || "auth_dom_login"
+    });
+  }
+  async trackEngagement() {
+    if (typeof window === "undefined" || !this.lastPath) return;
+    const durationMs = Date.now() - this.pageStartedAt;
+    const scrollHeight = Math.max(
+      document.documentElement.scrollHeight,
+      document.body?.scrollHeight || 0,
+      window.innerHeight
+    );
+    const scrollDepth = scrollHeight > 0 ? Math.min(1, (window.scrollY + window.innerHeight) / scrollHeight) : void 0;
+    await this.track("engagement", {
+      path: this.lastPath,
+      durationMs,
+      scrollDepth
+    });
+  }
+  async send(payload) {
+    const headers = {
+      "Content-Type": "text/plain;charset=UTF-8",
+      "X-Public-Key": this.config.publicKey
+    };
+    const accessToken = this.config.getAccessToken?.();
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`;
+    }
+    try {
+      await fetch(`${this.config.apiEndpoint}/api/dom-analytics/event`, {
+        method: "POST",
+        headers,
+        credentials: "include",
+        keepalive: true,
+        body: JSON.stringify(payload)
+      });
+    } catch (error) {
+      this.log("Analytics event failed:", error);
+    }
+  }
+  getClientSessionId() {
+    const key = `tiquo_analytics_session_${this.config.publicKey}`;
+    try {
+      const existing = sessionStorage.getItem(key);
+      if (existing) return existing;
+      const next = randomId();
+      sessionStorage.setItem(key, next);
+      return next;
+    } catch {
+      return randomId();
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[TiquoAnalytics]", ...args);
+    }
+  }
+  adoptConfig(nextConfig) {
+    if (nextConfig.getAccessToken) {
+      this.config.getAccessToken = nextConfig.getAccessToken;
+    }
+    if (nextConfig.siteSlug && !this.config.siteSlug) {
+      this.config.siteSlug = nextConfig.siteSlug;
+    }
+  }
+};
+_TiquoAnalytics.activeInstances = /* @__PURE__ */ new Map();
+var TiquoAnalytics = _TiquoAnalytics;
 var TiquoCMS = class {
   constructor(config) {
+    this.analytics = null;
     if (!config.publicKey) {
       throw new TiquoAuthError("publicKey is required", "MISSING_PUBLIC_KEY");
     }
@@ -655,8 +905,16 @@ var TiquoCMS = class {
     this.config = {
       publicKey: config.publicKey,
       apiEndpoint: config.apiEndpoint || "https://edge.tiquo.app",
-      debug: config.debug || false
+      debug: config.debug || false,
+      analytics: config.analytics !== false
     };
+    if (this.config.analytics) {
+      this.analytics = new TiquoAnalytics({
+        publicKey: this.config.publicKey,
+        apiEndpoint: this.config.apiEndpoint,
+        debug: this.config.debug
+      });
+    }
   }
   /**
    * Fetch a published CMS page for the website attached to this public key.
@@ -665,19 +923,22 @@ var TiquoCMS = class {
    * Convex connection details to the consuming website.
    */
   async getPage(request) {
-    const response = await fetch(`${this.config.apiEndpoint}/api/dom-cms/page`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "text/plain;charset=UTF-8"
-      },
-      credentials: "include",
-      body: JSON.stringify({
-        publicKey: this.config.publicKey,
-        siteSlug: request.siteSlug,
-        pageSlug: request.pageSlug || "home",
-        templateId: request.templateId
-      })
-    });
+    const response = await fetch(
+      `${this.config.apiEndpoint}/api/dom-cms/page`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "text/plain;charset=UTF-8"
+        },
+        credentials: "include",
+        body: JSON.stringify({
+          publicKey: this.config.publicKey,
+          siteSlug: request.siteSlug,
+          pageSlug: request.pageSlug || "home",
+          templateId: request.templateId
+        })
+      }
+    );
     if (response.status === 404) {
       return null;
     }
@@ -688,7 +949,11 @@ var TiquoCMS = class {
         if (typeof error?.error === "string") message = error.error;
       } catch {
       }
-      throw new TiquoAuthError(message, "CMS_PAGE_FETCH_FAILED", response.status);
+      throw new TiquoAuthError(
+        message,
+        "CMS_PAGE_FETCH_FAILED",
+        response.status
+      );
     }
     const result = await response.json();
     if (!result?.success || !result?.data) {
@@ -740,6 +1005,7 @@ var TiquoAuth = class {
     this.visibilityHandler = null;
     this.iframeObserver = null;
     this.injectedIframes = /* @__PURE__ */ new WeakSet();
+    this.analytics = null;
     // Multi-tab sync
     this.broadcastChannel = null;
     this.isProcessingTabSync = false;
@@ -760,10 +1026,19 @@ var TiquoAuth = class {
       debug: config.debug || false,
       enableTabSync: config.enableTabSync !== false,
       // Default true
+      analytics: config.analytics !== false,
       accessToken: config.accessToken,
       refreshToken: config.refreshToken
     };
     this.tabId = this.generateTabId();
+    if (this.config.analytics) {
+      this.analytics = new TiquoAnalytics({
+        publicKey: this.config.publicKey,
+        apiEndpoint: this.config.apiEndpoint,
+        debug: this.config.debug,
+        getAccessToken: () => this.accessToken
+      });
+    }
     if (this.config.enableTabSync) {
       this.initTabSync();
     }
@@ -789,7 +1064,11 @@ var TiquoAuth = class {
     });
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: "Failed to send OTP" }));
-      throw new TiquoAuthError(error.error || "Failed to send OTP", "OTP_SEND_FAILED", response.status);
+      throw new TiquoAuthError(
+        error.error || "Failed to send OTP",
+        "OTP_SEND_FAILED",
+        response.status
+      );
     }
     const result = await response.json();
     return {
@@ -812,7 +1091,11 @@ var TiquoAuth = class {
     });
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: "Invalid OTP" }));
-      throw new TiquoAuthError(error.error || "Invalid OTP", "OTP_VERIFY_FAILED", response.status);
+      throw new TiquoAuthError(
+        error.error || "Invalid OTP",
+        "OTP_VERIFY_FAILED",
+        response.status
+      );
     }
     const result = await response.json();
     this.accessToken = result.accessToken;
@@ -822,6 +1105,7 @@ var TiquoAuth = class {
     if (this.session?.user?.id) {
       addCustomerUserId(this.session.user.id);
     }
+    this.analytics?.identify({ identityLinkType: "auth_dom_login" }).catch(() => void 0);
     this.broadcastTabSync("LOGIN");
     return {
       success: true,
@@ -869,7 +1153,9 @@ var TiquoAuth = class {
   async updateProfile(updates) {
     await this.ensureValidToken();
     const normalizedUpdates = { ...updates };
-    const profilePhotoUpload = this.extractUploadableProfilePhoto(normalizedUpdates.profilePhoto);
+    const profilePhotoUpload = this.extractUploadableProfilePhoto(
+      normalizedUpdates.profilePhoto
+    );
     if (profilePhotoUpload) {
       delete normalizedUpdates.profilePhoto;
     }
@@ -877,7 +1163,12 @@ var TiquoAuth = class {
       const normalized = normalizePhone(normalizedUpdates.phone);
       const validation = validatePhone(normalizedUpdates.phone);
       if (!validation.valid) {
-        this.log("\u26A0\uFE0F Phone validation warning:", validation.reason, "- Original:", normalizedUpdates.phone);
+        this.log(
+          "\u26A0\uFE0F Phone validation warning:",
+          validation.reason,
+          "- Original:",
+          normalizedUpdates.phone
+        );
       } else {
         this.log("Phone normalized:", normalizedUpdates.phone, "\u2192", normalized);
       }
@@ -889,7 +1180,12 @@ var TiquoAuth = class {
         const normalized = normalizePhone(p.number);
         const validation = validatePhone(p.number);
         if (!validation.valid) {
-          this.log("\u26A0\uFE0F Phone validation warning:", validation.reason, "- Original:", p.number);
+          this.log(
+            "\u26A0\uFE0F Phone validation warning:",
+            validation.reason,
+            "- Original:",
+            p.number
+          );
         }
         return { ...p, number: normalized || p.number };
       });
@@ -903,7 +1199,11 @@ var TiquoAuth = class {
       });
       if (!response.ok) {
         const error = await response.json().catch(() => ({ error: "Failed to update profile" }));
-        throw new TiquoAuthError(error.error || "Failed to update profile", "PROFILE_UPDATE_FAILED", response.status);
+        throw new TiquoAuthError(
+          error.error || "Failed to update profile",
+          "PROFILE_UPDATE_FAILED",
+          response.status
+        );
       }
       const result = await response.json();
       if (this.session && result.data?.customer) {
@@ -935,12 +1235,18 @@ var TiquoAuth = class {
     await this.ensureValidToken();
     const blob = await this.profilePhotoToBlob(photo);
     if (!blob.type.startsWith("image/")) {
-      throw new TiquoAuthError("Profile photo must be an image", "INVALID_PROFILE_PHOTO");
+      throw new TiquoAuthError(
+        "Profile photo must be an image",
+        "INVALID_PROFILE_PHOTO"
+      );
     }
-    const uploadUrlResponse = await this.request("/api/client/v1/profile/photo-upload-url", {
-      method: "POST",
-      body: JSON.stringify({})
-    });
+    const uploadUrlResponse = await this.request(
+      "/api/client/v1/profile/photo-upload-url",
+      {
+        method: "POST",
+        body: JSON.stringify({})
+      }
+    );
     if (!uploadUrlResponse.ok) {
       const error = await uploadUrlResponse.json().catch(() => ({ error: "Failed to create profile photo upload URL" }));
       throw new TiquoAuthError(
@@ -952,7 +1258,10 @@ var TiquoAuth = class {
     const uploadUrlResult = await uploadUrlResponse.json();
     const uploadUrl = uploadUrlResult.data?.uploadUrl;
     if (!uploadUrl) {
-      throw new TiquoAuthError("Profile photo upload URL was missing", "PROFILE_PHOTO_UPLOAD_URL_FAILED");
+      throw new TiquoAuthError(
+        "Profile photo upload URL was missing",
+        "PROFILE_PHOTO_UPLOAD_URL_FAILED"
+      );
     }
     const uploadResponse = await fetch(uploadUrl, {
       method: "POST",
@@ -960,17 +1269,27 @@ var TiquoAuth = class {
       body: blob
     });
     if (!uploadResponse.ok) {
-      throw new TiquoAuthError("Failed to upload profile photo", "PROFILE_PHOTO_UPLOAD_FAILED", uploadResponse.status);
+      throw new TiquoAuthError(
+        "Failed to upload profile photo",
+        "PROFILE_PHOTO_UPLOAD_FAILED",
+        uploadResponse.status
+      );
     }
     const uploadResult = await uploadResponse.json();
     const storageId = uploadResult.storageId;
     if (!storageId) {
-      throw new TiquoAuthError("Profile photo storage ID was missing", "PROFILE_PHOTO_UPLOAD_FAILED");
+      throw new TiquoAuthError(
+        "Profile photo storage ID was missing",
+        "PROFILE_PHOTO_UPLOAD_FAILED"
+      );
     }
-    const finalizeResponse = await this.request("/api/client/v1/profile/photo", {
-      method: "POST",
-      body: JSON.stringify({ storageId })
-    });
+    const finalizeResponse = await this.request(
+      "/api/client/v1/profile/photo",
+      {
+        method: "POST",
+        body: JSON.stringify({ storageId })
+      }
+    );
     if (!finalizeResponse.ok) {
       const error = await finalizeResponse.json().catch(() => ({ error: "Failed to update profile photo" }));
       throw new TiquoAuthError(
@@ -983,7 +1302,10 @@ var TiquoAuth = class {
     const customer = finalizeResult.data?.customer;
     const profilePhoto = finalizeResult.data?.profilePhoto;
     if (!customer || !profilePhoto) {
-      throw new TiquoAuthError("Profile photo update response was incomplete", "PROFILE_PHOTO_UPDATE_FAILED");
+      throw new TiquoAuthError(
+        "Profile photo update response was incomplete",
+        "PROFILE_PHOTO_UPDATE_FAILED"
+      );
     }
     if (this.session && customer) {
       this.session = {
@@ -1058,13 +1380,17 @@ var TiquoAuth = class {
     const response = await fetch(url.toString(), {
       method: "GET",
       headers: {
-        "Authorization": `Bearer ${this.accessToken}`
+        Authorization: `Bearer ${this.accessToken}`
       },
       credentials: "include"
     });
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: "Failed to get orders" }));
-      throw new TiquoAuthError(error.error || "Failed to get orders", "GET_ORDERS_FAILED", response.status);
+      throw new TiquoAuthError(
+        error.error || "Failed to get orders",
+        "GET_ORDERS_FAILED",
+        response.status
+      );
     }
     const result = await response.json();
     return result.data || { orders: [], hasMore: false };
@@ -1096,17 +1422,51 @@ var TiquoAuth = class {
     const response = await fetch(url.toString(), {
       method: "GET",
       headers: {
-        "Authorization": `Bearer ${this.accessToken}`
+        Authorization: `Bearer ${this.accessToken}`
       },
       credentials: "include"
     });
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: "Failed to get bookings" }));
-      throw new TiquoAuthError(error.error || "Failed to get bookings", "GET_BOOKINGS_FAILED", response.status);
+      throw new TiquoAuthError(
+        error.error || "Failed to get bookings",
+        "GET_BOOKINGS_FAILED",
+        response.status
+      );
     }
     const result = await response.json();
     return result.data || { bookings: [], hasMore: false };
   }
+  /**
+   * Download a QR-code ticket PDF for one of the authenticated customer's bookings.
+   *
+   * This is only available when `booking.ticketing.qrCodeTicketsEnabled` is
+   * true in the booking list response.
+   */
+  async downloadBookingTicket(bookingId) {
+    await this.ensureValidToken();
+    this.log("Downloading booking ticket:", bookingId);
+    const url = new URL(
+      `${this.config.apiEndpoint}/api/client/v1/booking-ticket`
+    );
+    url.searchParams.set("bookingId", bookingId);
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${this.accessToken}`
+      },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to download booking ticket" }));
+      throw new TiquoAuthError(
+        error.error || "Failed to download booking ticket",
+        "DOWNLOAD_BOOKING_TICKET_FAILED",
+        response.status
+      );
+    }
+    return response.blob();
+  }
   /**
    * Convenience wrapper around `getBookings({ upcoming: true })` for the
    * common "show me my upcoming bookings" case. Results are sorted
@@ -1144,14 +1504,18 @@ var TiquoAuth = class {
     const response = await fetch(url.toString(), {
       method: "GET",
       headers: {
-        "Authorization": `Bearer ${this.accessToken}`
+        Authorization: `Bearer ${this.accessToken}`
       },
       credentials: "include"
     });
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: "Failed to get receipt" }));
       const code = response.status === 404 ? "RECEIPT_NOT_AVAILABLE" : "GET_RECEIPT_FAILED";
-      throw new TiquoAuthError(error.error || "Failed to get receipt", code, response.status);
+      throw new TiquoAuthError(
+        error.error || "Failed to get receipt",
+        code,
+        response.status
+      );
     }
     const result = await response.json();
     return result.data;
@@ -1176,13 +1540,17 @@ var TiquoAuth = class {
     const response = await fetch(url.toString(), {
       method: "GET",
       headers: {
-        "Authorization": `Bearer ${this.accessToken}`
+        Authorization: `Bearer ${this.accessToken}`
       },
       credentials: "include"
     });
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: "Failed to get enquiries" }));
-      throw new TiquoAuthError(error.error || "Failed to get enquiries", "GET_ENQUIRIES_FAILED", response.status);
+      throw new TiquoAuthError(
+        error.error || "Failed to get enquiries",
+        "GET_ENQUIRIES_FAILED",
+        response.status
+      );
     }
     const result = await response.json();
     return result.data || { enquiries: [], hasMore: false };
@@ -1200,16 +1568,23 @@ var TiquoAuth = class {
   async getCompanies() {
     await this.ensureValidToken();
     this.log("Fetching customer companies");
-    const response = await fetch(`${this.config.apiEndpoint}/api/client/v1/companies`, {
-      method: "GET",
-      headers: {
-        "Authorization": `Bearer ${this.accessToken}`
-      },
-      credentials: "include"
-    });
+    const response = await fetch(
+      `${this.config.apiEndpoint}/api/client/v1/companies`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.accessToken}`
+        },
+        credentials: "include"
+      }
+    );
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: "Failed to get companies" }));
-      throw new TiquoAuthError(error.error || "Failed to get companies", "GET_COMPANIES_FAILED", response.status);
+      throw new TiquoAuthError(
+        error.error || "Failed to get companies",
+        "GET_COMPANIES_FAILED",
+        response.status
+      );
     }
     const result = await response.json();
     return result.data || { companies: [] };
@@ -1231,19 +1606,25 @@ var TiquoAuth = class {
   async getCompanyColleagues(companyId) {
     await this.ensureValidToken();
     this.log("Fetching company colleagues for:", companyId);
-    const url = new URL(`${this.config.apiEndpoint}/api/client/v1/companies/colleagues`);
+    const url = new URL(
+      `${this.config.apiEndpoint}/api/client/v1/companies/colleagues`
+    );
     url.searchParams.set("companyId", companyId);
     const response = await fetch(url.toString(), {
       method: "GET",
       headers: {
-        "Authorization": `Bearer ${this.accessToken}`
+        Authorization: `Bearer ${this.accessToken}`
       },
       credentials: "include"
     });
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: "Failed to get colleagues" }));
       const code = response.status === 403 ? "NOT_COMPANY_ADMIN" : "GET_COLLEAGUES_FAILED";
-      throw new TiquoAuthError(error.error || "Failed to get colleagues", code, response.status);
+      throw new TiquoAuthError(
+        error.error || "Failed to get colleagues",
+        code,
+        response.status
+      );
     }
     const result = await response.json();
     return result.data;
@@ -1264,13 +1645,17 @@ var TiquoAuth = class {
     });
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: "Failed to generate token" }));
-      throw new TiquoAuthError(error.error || "Failed to generate token", "IFRAME_TOKEN_FAILED", response.status);
+      throw new TiquoAuthError(
+        error.error || "Failed to generate token",
+        "IFRAME_TOKEN_FAILED",
+        response.status
+      );
     }
     return response.json();
   }
   /**
    * Embed a customer flow with automatic authentication
-   * 
+   *
    * @param flowUrl - The URL of the customer flow (book.tiquo.app/...)
    * @param container - Container element or selector
    * @param options - Optional iframe configuration
@@ -1278,7 +1663,10 @@ var TiquoAuth = class {
   async embedCustomerFlow(flowUrl, container, options) {
     const containerEl = typeof container === "string" ? document.querySelector(container) : container;
     if (!containerEl) {
-      throw new TiquoAuthError("Container element not found", "CONTAINER_NOT_FOUND");
+      throw new TiquoAuthError(
+        "Container element not found",
+        "CONTAINER_NOT_FOUND"
+      );
     }
     let authToken;
     if (this.accessToken) {
@@ -1304,7 +1692,10 @@ var TiquoAuth = class {
       iframe.addEventListener("load", options.onLoad);
     }
     if (options?.onError) {
-      iframe.addEventListener("error", () => options.onError(new Error("Failed to load iframe")));
+      iframe.addEventListener(
+        "error",
+        () => options.onError(new Error("Failed to load iframe"))
+      );
     }
     containerEl.innerHTML = "";
     containerEl.appendChild(iframe);
@@ -1433,7 +1824,11 @@ var TiquoAuth = class {
         this.accessToken = accessToken;
         this.refreshToken = params.get("refresh_token");
         if (window.history?.replaceState) {
-          window.history.replaceState(null, "", window.location.pathname + window.location.search);
+          window.history.replaceState(
+            null,
+            "",
+            window.location.pathname + window.location.search
+          );
         }
         return;
       }
@@ -1461,7 +1856,10 @@ var TiquoAuth = class {
     if (typeof photo === "string" && this.isProfilePhotoBlobUrl(photo)) {
       const response = await fetch(photo);
       if (!response.ok) {
-        throw new TiquoAuthError("Failed to read profile photo URI", "INVALID_PROFILE_PHOTO");
+        throw new TiquoAuthError(
+          "Failed to read profile photo URI",
+          "INVALID_PROFILE_PHOTO"
+        );
       }
       return response.blob();
     }
@@ -1529,16 +1927,19 @@ var TiquoAuth = class {
     this.isRefreshing = true;
     this.log("Refreshing access token");
     try {
-      const response = await fetch(`${this.config.apiEndpoint}/api/client/v1/refresh`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          refresh_token: this.refreshToken
-        }),
-        credentials: "include"
-      });
+      const response = await fetch(
+        `${this.config.apiEndpoint}/api/client/v1/refresh`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            refresh_token: this.refreshToken
+          }),
+          credentials: "include"
+        }
+      );
       if (!response.ok) {
         this.log("Token refresh failed, clearing session");
         this.clearTokens();
@@ -1575,13 +1976,16 @@ var TiquoAuth = class {
     }
     try {
       await this.refreshTokenIfNeeded();
-      const response = await fetch(`${this.config.apiEndpoint}/api/client/v1/profile`, {
-        method: "GET",
-        headers: {
-          "Authorization": `Bearer ${this.accessToken}`
-        },
-        credentials: "include"
-      });
+      const response = await fetch(
+        `${this.config.apiEndpoint}/api/client/v1/profile`,
+        {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          },
+          credentials: "include"
+        }
+      );
       if (!response.ok) {
         this.log("Session invalid, clearing");
         this.clearTokens();
@@ -1599,6 +2003,9 @@ var TiquoAuth = class {
         if (this.session.user?.id) {
           addCustomerUserId(this.session.user.id);
         }
+        if (this.session.customer) {
+          this.analytics?.identify({ identityLinkType: "auth_dom_login" }).catch(() => void 0);
+        }
         this.notifyListeners();
         this.scheduleRefresh();
         return this.session;
@@ -1633,8 +2040,12 @@ var TiquoAuth = class {
       return;
     }
     try {
-      const accessToken = localStorage.getItem(`${this.config.storagePrefix}access_token`);
-      const refreshToken = localStorage.getItem(`${this.config.storagePrefix}refresh_token`);
+      const accessToken = localStorage.getItem(
+        `${this.config.storagePrefix}access_token`
+      );
+      const refreshToken = localStorage.getItem(
+        `${this.config.storagePrefix}refresh_token`
+      );
       if (accessToken) {
         this.accessToken = accessToken;
         this.refreshToken = refreshToken;
@@ -1746,7 +2157,12 @@ var TiquoAuth = class {
     if (message.tabId === this.tabId) return;
     if (this.isProcessingTabSync) return;
     this.isProcessingTabSync = true;
-    this.log("Received tab sync message:", message.type, "from tab:", message.tabId);
+    this.log(
+      "Received tab sync message:",
+      message.type,
+      "from tab:",
+      message.tabId
+    );
     try {
       switch (message.type) {
         case "LOGIN":
@@ -1773,7 +2189,9 @@ var TiquoAuth = class {
           }
           try {
             localStorage.removeItem(`${this.config.storagePrefix}access_token`);
-            localStorage.removeItem(`${this.config.storagePrefix}refresh_token`);
+            localStorage.removeItem(
+              `${this.config.storagePrefix}refresh_token`
+            );
           } catch {
           }
           this.notifyListeners();
@@ -1876,6 +2294,7 @@ TiquoPhone.getDialCode = getDialCode;
 TiquoPhone.buildPhone = buildPhone;
 var index_default = TiquoAuth;
 export {
+  TiquoAnalytics,
   TiquoAuth,
   TiquoAuthError,
   TiquoCMS,