@tiquo/dom-package 1.5.0 → 1.5.2

package/dist/index.mjs

@@ -641,6 +641,333 @@ 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");
+    }
+    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,
+      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.
+   *
+   * This intentionally goes through the Tiquo edge API rather than exposing
+   * 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
+        })
+      }
+    );
+    if (response.status === 404) {
+      return null;
+    }
+    if (!response.ok) {
+      let message = "Failed to fetch CMS page";
+      try {
+        const error = await response.json();
+        if (typeof error?.error === "string") message = error.error;
+      } catch {
+      }
+      throw new TiquoAuthError(
+        message,
+        "CMS_PAGE_FETCH_FAILED",
+        response.status
+      );
+    }
+    const result = await response.json();
+    if (!result?.success || !result?.data) {
+      return null;
+    }
+    this.log("Fetched CMS page", request.siteSlug, request.pageSlug || "home");
+    return result.data;
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[TiquoCMS]", ...args);
+    }
+  }
+};
 var TiquoAuthError = class extends Error {
   constructor(message, code, statusCode) {
     super(message);
@@ -678,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;
@@ -698,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();
     }
@@ -727,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 {
@@ -750,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;
@@ -760,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,
@@ -807,11 +1153,22 @@ var TiquoAuth = class {
   async updateProfile(updates) {
     await this.ensureValidToken();
     const normalizedUpdates = { ...updates };
+    const profilePhotoUpload = this.extractUploadableProfilePhoto(
+      normalizedUpdates.profilePhoto
+    );
+    if (profilePhotoUpload) {
+      delete normalizedUpdates.profilePhoto;
+    }
     if (normalizedUpdates.phone !== void 0 && normalizedUpdates.phone !== "") {
       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);
       }
@@ -823,32 +1180,146 @@ 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 };
       });
     }
     this.log("Updating customer profile:", normalizedUpdates);
-    const response = await this.request("/api/client/v1/profile", {
-      method: "PATCH",
-      body: JSON.stringify(normalizedUpdates)
+    let customer = this.session?.customer || void 0;
+    if (Object.keys(normalizedUpdates).length > 0) {
+      const response = await this.request("/api/client/v1/profile", {
+        method: "PATCH",
+        body: JSON.stringify(normalizedUpdates)
+      });
+      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
+        );
+      }
+      const result = await response.json();
+      if (this.session && result.data?.customer) {
+        this.session = {
+          ...this.session,
+          customer: result.data.customer
+        };
+        this.notifyListeners();
+        this.broadcastTabSync("SESSION_UPDATE");
+      }
+      customer = result.data?.customer;
+    }
+    if (profilePhotoUpload) {
+      return this.uploadProfilePhoto(profilePhotoUpload);
+    }
+    return {
+      success: true,
+      customer
+    };
+  }
+  /**
+   * Upload and save the authenticated customer's profile photo.
+   *
+   * Accepts a browser File/Blob, `data:image/...` URI, or `blob:...` URI. The
+   * image is uploaded to Tiquo storage first, and the customer profile is
+   * updated with the URL.
+   */
+  async uploadProfilePhoto(photo) {
+    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"
+      );
+    }
+    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(
+        error.error || "Failed to create profile photo upload URL",
+        "PROFILE_PHOTO_UPLOAD_URL_FAILED",
+        uploadUrlResponse.status
+      );
+    }
+    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"
+      );
+    }
+    const uploadResponse = await fetch(uploadUrl, {
+      method: "POST",
+      headers: { "Content-Type": blob.type },
+      body: blob
     });
-    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);
+    if (!uploadResponse.ok) {
+      throw new TiquoAuthError(
+        "Failed to upload profile photo",
+        "PROFILE_PHOTO_UPLOAD_FAILED",
+        uploadResponse.status
+      );
     }
-    const result = await response.json();
-    if (this.session && result.data?.customer) {
+    const uploadResult = await uploadResponse.json();
+    const storageId = uploadResult.storageId;
+    if (!storageId) {
+      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 })
+      }
+    );
+    if (!finalizeResponse.ok) {
+      const error = await finalizeResponse.json().catch(() => ({ error: "Failed to update profile photo" }));
+      throw new TiquoAuthError(
+        error.error || "Failed to update profile photo",
+        "PROFILE_PHOTO_UPDATE_FAILED",
+        finalizeResponse.status
+      );
+    }
+    const finalizeResult = await finalizeResponse.json();
+    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"
+      );
+    }
+    if (this.session && customer) {
       this.session = {
         ...this.session,
-        customer: result.data.customer
+        customer
       };
       this.notifyListeners();
       this.broadcastTabSync("SESSION_UPDATE");
     }
     return {
       success: true,
-      customer: result.data?.customer
+      customer,
+      profilePhoto,
+      storageId
     };
   }
   /**
@@ -909,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 };
@@ -947,13 +1422,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 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 };
@@ -995,14 +1474,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;
@@ -1027,13 +1510,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 };
@@ -1051,16 +1538,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: [] };
@@ -1082,19 +1576,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;
@@ -1115,13 +1615,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
@@ -1129,7 +1633,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) {
@@ -1155,7 +1662,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);
@@ -1284,12 +1794,50 @@ 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;
       }
     }
   }
+  extractUploadableProfilePhoto(profilePhoto) {
+    if (typeof Blob !== "undefined" && profilePhoto instanceof Blob) {
+      return profilePhoto;
+    }
+    if (typeof profilePhoto === "string") {
+      const trimmed = profilePhoto.trim();
+      if (trimmed.startsWith("data:") || trimmed.startsWith("blob:")) {
+        return trimmed;
+      }
+    }
+    return null;
+  }
+  isProfilePhotoBlobUrl(photo) {
+    return photo.trim().startsWith("data:") || photo.trim().startsWith("blob:");
+  }
+  async profilePhotoToBlob(photo) {
+    if (typeof Blob !== "undefined" && photo instanceof Blob) {
+      return photo;
+    }
+    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"
+        );
+      }
+      return response.blob();
+    }
+    throw new TiquoAuthError(
+      "uploadProfilePhoto expects a File, Blob, data URI, or blob URI. Use updateProfile({ profilePhoto: url }) for remote URLs.",
+      "INVALID_PROFILE_PHOTO"
+    );
+  }
   async request(path, options) {
     const url = `${this.config.apiEndpoint}${path}`;
     const headers = {
@@ -1349,16 +1897,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();
@@ -1395,13 +1946,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();
@@ -1419,6 +1973,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;
@@ -1453,8 +2010,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;
@@ -1566,7 +2127,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":
@@ -1593,7 +2159,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();
@@ -1665,6 +2233,7 @@ function useTiquoAuth(auth) {
     verifyOTP: (email, otp) => auth.verifyOTP(email, otp),
     logout: () => auth.logout(),
     updateProfile: (updates) => auth.updateProfile(updates),
+    uploadProfilePhoto: (photo) => auth.uploadProfilePhoto(photo),
     getOrders: (options) => auth.getOrders(options),
     getBookings: (options) => auth.getBookings(options),
     getUpcomingBookings: (options) => auth.getUpcomingBookings(options),
@@ -1695,8 +2264,10 @@ TiquoPhone.getDialCode = getDialCode;
 TiquoPhone.buildPhone = buildPhone;
 var index_default = TiquoAuth;
 export {
+  TiquoAnalytics,
   TiquoAuth,
   TiquoAuthError,
+  TiquoCMS,
   TiquoPhone,
   addCustomerUserId,
   clearCachedEmail,