@tolinku/web-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,910 @@
+// src/client.ts
+var MAX_RETRIES = 3;
+var BASE_DELAY_MS = 500;
+var MAX_JITTER_MS = 250;
+var HttpClient = class {
+  constructor(config) {
+    this.abortController = null;
+    this._baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+  }
+  /** Abort all in-flight requests (called by Tolinku.destroy()) */
+  abort() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+  /** Get a signal for the current request batch, creating a controller if needed */
+  get signal() {
+    if (!this.abortController) {
+      this.abortController = new AbortController();
+    }
+    return this.abortController.signal;
+  }
+  /** Public accessor for the base URL */
+  get baseUrl() {
+    return this._baseUrl;
+  }
+  /** Public accessor for the API key (used by sendBeacon which cannot set custom headers) */
+  get key() {
+    return this.apiKey;
+  }
+  async get(path, params) {
+    let url = this._baseUrl + path;
+    if (params) {
+      const qs = new URLSearchParams(params).toString();
+      if (qs) url += "?" + qs;
+    }
+    const res = await this.fetchWithRetry(url, {
+      method: "GET",
+      headers: this.headers(),
+      signal: this.signal
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: res.statusText }));
+      throw new TolinkuError(body.error || res.statusText, res.status, body.code);
+    }
+    return this.parseJson(res);
+  }
+  async post(path, body) {
+    const res = await this.fetchWithRetry(this._baseUrl + path, {
+      method: "POST",
+      headers: {
+        ...this.headers(),
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0,
+      signal: this.signal
+    });
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({ error: res.statusText }));
+      throw new TolinkuError(data.error || res.statusText, res.status, data.code);
+    }
+    return this.parseJson(res);
+  }
+  /** GET without API key auth (for public endpoints like banner config) */
+  async getPublic(path, params) {
+    let url = this._baseUrl + path;
+    if (params) {
+      const qs = new URLSearchParams(params).toString();
+      if (qs) url += "?" + qs;
+    }
+    const res = await this.fetchWithRetry(url, {
+      method: "GET",
+      signal: this.signal
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({ error: res.statusText }));
+      throw new TolinkuError(body.error || res.statusText, res.status, body.code);
+    }
+    return this.parseJson(res);
+  }
+  /** POST without API key auth (for public endpoints like deferred claim) */
+  async postPublic(path, body) {
+    const res = await this.fetchWithRetry(this._baseUrl + path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: body ? JSON.stringify(body) : void 0,
+      signal: this.signal
+    });
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({ error: res.statusText }));
+      throw new TolinkuError(data.error || res.statusText, res.status, data.code);
+    }
+    return this.parseJson(res);
+  }
+  /**
+   * Fetch with retry logic. Retries on network errors, HTTP 429, and 5xx responses.
+   * Uses exponential backoff: BASE_DELAY_MS * 2^attempt + random jitter.
+   * Respects Retry-After header on 429 responses.
+   * Does NOT retry on 4xx errors (except 429) or successful responses.
+   */
+  async fetchWithRetry(url, init) {
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        const res = await fetch(url, init);
+        if (res.ok || res.status >= 400 && res.status < 500 && res.status !== 429) {
+          return res;
+        }
+        if (attempt < MAX_RETRIES) {
+          const delay = this.computeDelay(attempt, res);
+          await this.sleep(delay, init.signal);
+          continue;
+        }
+        return res;
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") {
+          throw err;
+        }
+        lastError = err;
+        if (attempt < MAX_RETRIES) {
+          const delay = this.computeDelay(attempt);
+          await this.sleep(delay, init.signal);
+          continue;
+        }
+      }
+    }
+    throw lastError;
+  }
+  /** Compute backoff delay: BASE_DELAY_MS * 2^attempt + random jitter (0 to MAX_JITTER_MS) */
+  computeDelay(attempt, res) {
+    if (res && res.status === 429) {
+      const retryAfter = res.headers.get("Retry-After");
+      if (retryAfter) {
+        const seconds = Number(retryAfter);
+        if (!isNaN(seconds) && seconds > 0) {
+          return seconds * 1e3;
+        }
+      }
+    }
+    const exponential = BASE_DELAY_MS * Math.pow(2, attempt);
+    const jitter = Math.random() * MAX_JITTER_MS;
+    return exponential + jitter;
+  }
+  /** Sleep for a given duration, but throw if the signal is aborted */
+  sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(new DOMException("The operation was aborted.", "AbortError"));
+        return;
+      }
+      const timer = setTimeout(resolve, ms);
+      signal?.addEventListener("abort", () => {
+        clearTimeout(timer);
+        reject(new DOMException("The operation was aborted.", "AbortError"));
+      }, { once: true });
+    });
+  }
+  /** Safely parse JSON from a response, handling non-JSON 200s */
+  async parseJson(res) {
+    try {
+      return await res.json();
+    } catch {
+      throw new TolinkuError("Invalid JSON in response body", res.status);
+    }
+  }
+  headers() {
+    return {
+      "X-API-Key": this.apiKey
+    };
+  }
+};
+var TolinkuError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.name = "TolinkuError";
+    this.status = status;
+    this.code = code;
+  }
+};
+
+// src/analytics.ts
+var BATCH_SIZE = 10;
+var FLUSH_INTERVAL_MS = 5e3;
+var MAX_QUEUE_SIZE = 1e3;
+var Analytics = class {
+  constructor(client) {
+    this.client = client;
+    this.queue = [];
+    this.flushTimer = null;
+    this.unloadHandler = null;
+    if (typeof window !== "undefined") {
+      this.unloadHandler = () => this.flushBeacon();
+      window.addEventListener("beforeunload", this.unloadHandler);
+    }
+  }
+  /**
+   * Track a custom event. Event type must start with "custom." and match
+   * the pattern custom.[a-z0-9_]+
+   *
+   * Events are queued and sent in batches for efficiency.
+   */
+  async track(eventType, properties) {
+    if (typeof eventType !== "string" || eventType.trim().length === 0) {
+      throw new Error("Tolinku: event name must be a non-empty string");
+    }
+    if (!eventType.startsWith("custom.")) {
+      eventType = "custom." + eventType;
+    }
+    const eventNameRegex = /^custom\.[a-z0-9_]+$/;
+    if (!eventNameRegex.test(eventType)) {
+      throw new Error(
+        `Tolinku: event name "${eventType}" is invalid. Event names must match the pattern "custom.[a-z0-9_]+" (lowercase letters, numbers, and underscores only after "custom.")`
+      );
+    }
+    this.queue.push({
+      event_type: eventType,
+      properties: properties || {}
+    });
+    if (this.queue.length === 1 && !this.flushTimer) {
+      this.flushTimer = setTimeout(() => {
+        this.flushTimer = null;
+        this.flush();
+      }, FLUSH_INTERVAL_MS);
+    }
+    if (this.queue.length >= BATCH_SIZE) {
+      await this.flush();
+    }
+  }
+  /** Send all queued events to the server */
+  async flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.queue.length === 0) return;
+    const events = this.queue.splice(0);
+    try {
+      const result = await this.client.post("/v1/api/analytics/batch", { events });
+      if (result.errors && result.errors.length > 0) {
+        console.warn("[TolinkuSDK] Batch partial failure:", result.errors);
+      }
+    } catch {
+      this.queue.unshift(...events);
+      if (this.queue.length > MAX_QUEUE_SIZE) {
+        this.queue.splice(0, this.queue.length - MAX_QUEUE_SIZE);
+      }
+    }
+  }
+  /**
+   * Flush remaining events using navigator.sendBeacon (best-effort).
+   * Called on page unload when a normal fetch may not complete.
+   */
+  flushBeacon() {
+    if (this.queue.length === 0) return;
+    const events = this.queue.splice(0);
+    const url = this.client.baseUrl + "/v1/api/analytics/batch";
+    const body = JSON.stringify({ events, apiKey: this.client.key });
+    if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
+      navigator.sendBeacon(url, new Blob([body], { type: "application/json" }));
+    }
+  }
+  /** Clean up timers and event listeners. Called by Tolinku.destroy(). */
+  destroy() {
+    this.flushBeacon();
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (typeof window !== "undefined" && this.unloadHandler) {
+      window.removeEventListener("beforeunload", this.unloadHandler);
+      this.unloadHandler = null;
+    }
+  }
+};
+
+// src/referrals.ts
+var Referrals = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a new referral for a user */
+  async create(options) {
+    return this.client.post("/v1/api/referral/create", {
+      user_id: options.userId,
+      metadata: options.metadata,
+      user_name: options.userName
+    });
+  }
+  /** Get referral info by code */
+  async get(code) {
+    return this.client.get(`/v1/api/referral/${encodeURIComponent(code)}`);
+  }
+  /** Complete a referral (mark as converted) */
+  async complete(options) {
+    return this.client.post("/v1/api/referral/complete", {
+      referral_code: options.code,
+      referred_user_id: options.referredUserId,
+      milestone: options.milestone,
+      referred_user_name: options.referredUserName
+    });
+  }
+  /** Update a referral milestone */
+  async milestone(options) {
+    return this.client.post("/v1/api/referral/milestone", {
+      referral_code: options.code,
+      milestone: options.milestone
+    });
+  }
+  /** Claim a referral reward */
+  async claimReward(code) {
+    return this.client.post("/v1/api/referral/claim-reward", {
+      referral_code: code
+    });
+  }
+  /** Get the referral leaderboard */
+  async leaderboard(limit = 25) {
+    return this.client.get("/v1/api/referral/leaderboard", {
+      limit: String(limit)
+    });
+  }
+};
+
+// src/deferred.ts
+var Deferred = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Claim a deferred deep link by referrer token (from Play Store referrer or clipboard) */
+  async claimByToken(token) {
+    try {
+      return await this.client.getPublic("/v1/api/deferred/claim", { token });
+    } catch (err) {
+      console.warn("[Tolinku] Failed to claim deferred link by token:", err);
+      return null;
+    }
+  }
+  /** Claim a deferred deep link by device signal matching */
+  async claimBySignals(options) {
+    try {
+      return await this.client.postPublic("/v1/api/deferred/claim-by-signals", {
+        appspace_id: options.appspaceId,
+        timezone: options.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
+        language: options.language || navigator.language,
+        screen_width: options.screenWidth || window.screen.width,
+        screen_height: options.screenHeight || window.screen.height
+      });
+    } catch (err) {
+      console.warn("[Tolinku] Failed to claim deferred link by signals:", err);
+      return null;
+    }
+  }
+};
+
+// src/storage.ts
+var BANNER_KEY = "tolinku_banner_dismissed";
+var MESSAGE_KEY = "tolinku_message_dismissed";
+var MESSAGE_IMPRESSIONS_KEY = "tolinku_message_impressions";
+var MESSAGE_LAST_SHOWN_KEY = "tolinku_message_last_shown";
+function getStore(key) {
+  try {
+    return JSON.parse(localStorage.getItem(key) || "{}");
+  } catch {
+    return {};
+  }
+}
+function setStore(key, data) {
+  try {
+    localStorage.setItem(key, JSON.stringify(data));
+  } catch {
+  }
+}
+function isBannerDismissed(bannerId, dismissDays) {
+  if (!dismissDays || dismissDays <= 0) return false;
+  const data = getStore(BANNER_KEY);
+  const entry = data[bannerId];
+  if (!entry) return false;
+  const dismissedAt = new Date(entry).getTime();
+  return Date.now() - dismissedAt < dismissDays * 864e5;
+}
+function saveBannerDismissal(bannerId) {
+  const data = getStore(BANNER_KEY);
+  data[bannerId] = (/* @__PURE__ */ new Date()).toISOString();
+  setStore(BANNER_KEY, data);
+}
+function isMessageDismissed(messageId, dismissDays) {
+  if (!dismissDays || dismissDays <= 0) return false;
+  const data = getStore(MESSAGE_KEY);
+  const entry = data[messageId];
+  if (!entry) return false;
+  const dismissedAt = new Date(entry).getTime();
+  return Date.now() - dismissedAt < dismissDays * 864e5;
+}
+function saveMessageDismissal(messageId) {
+  const data = getStore(MESSAGE_KEY);
+  data[messageId] = (/* @__PURE__ */ new Date()).toISOString();
+  setStore(MESSAGE_KEY, data);
+}
+function isMessageSuppressed(messageId, maxImpressions, minIntervalHours) {
+  if (maxImpressions !== null && maxImpressions > 0) {
+    const impressions = getStore(MESSAGE_IMPRESSIONS_KEY);
+    const count = parseInt(impressions[messageId] || "0", 10);
+    if (count >= maxImpressions) return true;
+  }
+  if (minIntervalHours !== null && minIntervalHours > 0) {
+    const lastShown = getStore(MESSAGE_LAST_SHOWN_KEY);
+    const entry = lastShown[messageId];
+    if (entry) {
+      const lastShownAt = new Date(entry).getTime();
+      const intervalMs = minIntervalHours * 36e5;
+      if (Date.now() - lastShownAt < intervalMs) return true;
+    }
+  }
+  return false;
+}
+function recordMessageImpression(messageId) {
+  const impressions = getStore(MESSAGE_IMPRESSIONS_KEY);
+  const count = parseInt(impressions[messageId] || "0", 10);
+  impressions[messageId] = String(count + 1);
+  setStore(MESSAGE_IMPRESSIONS_KEY, impressions);
+  const lastShown = getStore(MESSAGE_LAST_SHOWN_KEY);
+  lastShown[messageId] = (/* @__PURE__ */ new Date()).toISOString();
+  setStore(MESSAGE_LAST_SHOWN_KEY, lastShown);
+}
+
+// src/sanitize.ts
+function sanitizeCssColor(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (/[;{}]/.test(trimmed)) return null;
+  if (/^#([0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(trimmed)) return trimmed;
+  if (/^(rgb|rgba|hsl|hsla)\([0-9a-zA-Z,.%\s/]+\)$/.test(trimmed)) return trimmed;
+  if (/^[a-zA-Z-]{1,30}$/.test(trimmed)) return trimmed;
+  return null;
+}
+
+// src/banners.ts
+var Banners = class {
+  constructor(client) {
+    this.client = client;
+    this.container = null;
+    this.styleEl = null;
+  }
+  /** Fetch banner config and show the highest-priority banner */
+  async show(options = {}, userId) {
+    const params = {};
+    if (userId) params.user_id = userId;
+    const config = await this.client.getPublic("/v1/api/banner/config", params);
+    if (!config.enabled || !config.banners || config.banners.length === 0) return;
+    config.banners.sort((a, b) => b.priority - a.priority);
+    let banner = null;
+    for (const b of config.banners) {
+      if (options.label && b.label !== options.label) continue;
+      if (!isBannerDismissed(b.id, b.dismiss_days)) {
+        banner = b;
+        break;
+      }
+    }
+    if (!banner) return;
+    this.render(config, banner, options);
+  }
+  /** Remove the banner from the DOM */
+  dismiss() {
+    if (this.container) {
+      this.container.classList.remove("tolk-visible");
+      const pos = this.container.dataset.position || "top";
+      document.body.style.removeProperty(pos === "top" ? "padding-top" : "padding-bottom");
+      setTimeout(() => {
+        this.container?.remove();
+        this.styleEl?.remove();
+        this.container = null;
+        this.styleEl = null;
+      }, 400);
+    }
+  }
+  render(config, banner, options) {
+    if (this.container) {
+      this.container.remove();
+      this.styleEl?.remove();
+    }
+    const position = options.position || banner.position || "top";
+    const bgColor = sanitizeCssColor(banner.background_color) || "#ffffff";
+    const textColor = sanitizeCssColor(banner.text_color) || "#000000";
+    const ctaText = banner.cta_text || "Open";
+    const baseUrl = this.client.baseUrl;
+    const installUrl = banner.action_url || baseUrl + (config.install_url || "/install");
+    const safeTop = position === "top" ? "padding-top: env(safe-area-inset-top, 0px);" : "";
+    const safeBottom = position === "bottom" ? "padding-bottom: env(safe-area-inset-bottom, 0px);" : "";
+    const container = document.createElement("div");
+    container.id = "tolinku-banner";
+    container.setAttribute("role", "banner");
+    container.setAttribute("aria-live", "polite");
+    container.dataset.position = position;
+    const style = document.createElement("style");
+    style.textContent = `
+      #tolinku-banner {
+        position: fixed;
+        ${position}: 0;
+        left: 0; right: 0;
+        z-index: 999999;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+        transform: translateY(${position === "top" ? "-100%" : "100%"});
+        transition: transform 0.35s ease;
+        ${safeTop}${safeBottom}
+      }
+      #tolinku-banner.tolk-visible { transform: translateY(0); }
+      #tolinku-banner .tolk-inner {
+        display: flex; align-items: center; gap: 10px;
+        padding: 10px 14px;
+        background: ${bgColor}; color: ${textColor};
+        box-shadow: 0 2px 8px rgba(0,0,0,0.15);
+      }
+      #tolinku-banner .tolk-close {
+        background: none; border: none; font-size: 20px; line-height: 1;
+        cursor: pointer; color: ${textColor}; opacity: 0.6; padding: 0 4px; flex-shrink: 0;
+      }
+      #tolinku-banner .tolk-close:hover { opacity: 1; }
+      #tolinku-banner .tolk-icon {
+        width: 40px; height: 40px; border-radius: 10px; flex-shrink: 0; object-fit: cover;
+      }
+      #tolinku-banner .tolk-text { flex: 1; min-width: 0; }
+      #tolinku-banner .tolk-title {
+        font-size: 14px; font-weight: 600; margin: 0;
+        white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
+      }
+      #tolinku-banner .tolk-body {
+        font-size: 12px; margin: 0; opacity: 0.75;
+        white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
+      }
+      #tolinku-banner .tolk-cta {
+        display: inline-block; padding: 6px 16px; border-radius: 100px;
+        font-size: 13px; font-weight: 600; text-decoration: none;
+        background: ${textColor}; color: ${bgColor}; flex-shrink: 0; text-align: center;
+      }
+    `;
+    const inner = document.createElement("div");
+    inner.className = "tolk-inner";
+    const closeBtn = document.createElement("button");
+    closeBtn.className = "tolk-close";
+    closeBtn.setAttribute("aria-label", "Dismiss banner");
+    closeBtn.textContent = "\xD7";
+    closeBtn.addEventListener("click", () => {
+      saveBannerDismissal(banner.id);
+      this.dismiss();
+    });
+    inner.appendChild(closeBtn);
+    if (config.app_icon && isSafeUrl(config.app_icon)) {
+      const icon = document.createElement("img");
+      icon.className = "tolk-icon";
+      icon.src = config.app_icon;
+      icon.alt = config.app_name || "App";
+      inner.appendChild(icon);
+    }
+    const textWrap = document.createElement("div");
+    textWrap.className = "tolk-text";
+    const titleEl = document.createElement("p");
+    titleEl.className = "tolk-title";
+    titleEl.textContent = banner.title || config.app_name || "Get the App";
+    textWrap.appendChild(titleEl);
+    if (banner.body) {
+      const bodyEl = document.createElement("p");
+      bodyEl.className = "tolk-body";
+      bodyEl.textContent = banner.body;
+      textWrap.appendChild(bodyEl);
+    }
+    inner.appendChild(textWrap);
+    const cta = document.createElement("a");
+    cta.className = "tolk-cta";
+    cta.href = isSafeUrl(installUrl) ? installUrl : "#";
+    cta.textContent = ctaText;
+    inner.appendChild(cta);
+    container.appendChild(inner);
+    document.head.appendChild(style);
+    document.body.appendChild(container);
+    this.container = container;
+    this.styleEl = style;
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        container.classList.add("tolk-visible");
+        const bannerHeight = container.offsetHeight + "px";
+        if (position === "top") {
+          document.body.style.paddingTop = bannerHeight;
+        } else {
+          document.body.style.paddingBottom = bannerHeight;
+        }
+      });
+    });
+  }
+};
+function isSafeUrl(url) {
+  try {
+    const parsed = new URL(url, window.location.href);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+// src/messages.ts
+var Messages = class {
+  constructor(client) {
+    this.client = client;
+    this.overlay = null;
+    this.styleEl = null;
+  }
+  /** Fetch messages and show the highest-priority non-dismissed one */
+  async show(options = {}, userId) {
+    const params = {};
+    if (options.trigger) params.trigger = options.trigger;
+    if (userId) params.user_id = userId;
+    const data = await this.client.get("/v1/api/messages", params);
+    if (!data.messages || data.messages.length === 0) return;
+    const candidates = data.messages.filter((m) => !isMessageDismissed(m.id, m.dismiss_days)).filter((m) => !isMessageSuppressed(m.id, m.max_impressions, m.min_interval_hours)).filter((m) => !options.triggerValue || m.trigger_value === options.triggerValue).sort((a, b) => b.priority - a.priority);
+    if (candidates.length === 0) return;
+    const message = candidates[0];
+    recordMessageImpression(message.id);
+    this.render(message, options);
+  }
+  /** Remove the message overlay */
+  dismiss() {
+    if (this.overlay) {
+      this.overlay.style.opacity = "0";
+      setTimeout(() => {
+        this.overlay?.remove();
+        this.styleEl?.remove();
+        this.overlay = null;
+        this.styleEl = null;
+      }, 300);
+    }
+  }
+  render(message, options) {
+    if (this.overlay) {
+      this.overlay.remove();
+      this.styleEl?.remove();
+    }
+    const style = document.createElement("style");
+    style.textContent = `
+      .tolk-msg-overlay {
+        position: fixed; top: 0; right: 0; bottom: 0; left: 0; z-index: 1000000;
+        display: flex; align-items: center; justify-content: center;
+        background: rgba(0,0,0,0.5);
+        opacity: 0; transition: opacity 0.3s ease;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      }
+      .tolk-msg-overlay.tolk-visible { opacity: 1; }
+      .tolk-msg-card {
+        position: relative; max-width: 375px; width: 90%;
+        max-height: 80vh; overflow-y: auto;
+        border-radius: 16px; padding: 24px;
+        box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+      }
+      .tolk-msg-close {
+        position: absolute; top: 12px; right: 12px;
+        background: rgba(0,0,0,0.1); border: none; border-radius: 50%;
+        width: 28px; height: 28px; font-size: 16px; line-height: 1;
+        cursor: pointer; display: flex; align-items: center; justify-content: center;
+        color: inherit; opacity: 0.6;
+      }
+      .tolk-msg-close:hover { opacity: 1; }
+    `;
+    const overlay = document.createElement("div");
+    overlay.className = "tolk-msg-overlay";
+    overlay.addEventListener("click", (e) => {
+      if (e.target === overlay) {
+        saveMessageDismissal(message.id);
+        options.onDismiss?.(message.id);
+        this.dismiss();
+      }
+    });
+    const card = document.createElement("div");
+    card.className = "tolk-msg-card";
+    card.style.background = sanitizeCssColor(message.background_color) || "#ffffff";
+    const closeBtn = document.createElement("button");
+    closeBtn.className = "tolk-msg-close";
+    closeBtn.setAttribute("aria-label", "Close message");
+    closeBtn.textContent = "\xD7";
+    closeBtn.addEventListener("click", () => {
+      saveMessageDismissal(message.id);
+      options.onDismiss?.(message.id);
+      this.dismiss();
+    });
+    card.appendChild(closeBtn);
+    if (message.content && message.content.content) {
+      for (const component of message.content.content) {
+        const el = this.renderComponent(component, message.id, options);
+        if (el) card.appendChild(el);
+      }
+    }
+    overlay.appendChild(card);
+    document.head.appendChild(style);
+    document.body.appendChild(overlay);
+    this.overlay = overlay;
+    this.styleEl = style;
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        overlay.classList.add("tolk-visible");
+      });
+    });
+  }
+  renderComponent(component, messageId, options) {
+    const props = component.props;
+    switch (component.type) {
+      case "Heading": {
+        const el = document.createElement("h2");
+        el.textContent = props.text || "";
+        el.style.fontSize = (props.fontSize || 28) + "px";
+        el.style.fontWeight = "700";
+        el.style.color = sanitizeCssColor(props.color) || "#1B1B1B";
+        el.style.textAlign = sanitizeTextAlign(props.alignment);
+        el.style.lineHeight = "1.2";
+        el.style.margin = "0 0 8px 0";
+        return el;
+      }
+      case "TextBlock": {
+        const el = document.createElement("p");
+        el.textContent = props.content || "";
+        el.style.fontSize = (props.fontSize || 15) + "px";
+        el.style.color = sanitizeCssColor(props.color) || "#555555";
+        el.style.textAlign = sanitizeTextAlign(props.alignment);
+        el.style.lineHeight = "1.5";
+        el.style.margin = "0 0 8px 0";
+        return el;
+      }
+      case "Image": {
+        const url = props.url || "";
+        if (!isSafeUrl2(url)) return null;
+        const el = document.createElement("img");
+        el.src = url;
+        el.alt = props.alt || "";
+        const width = props.width || "100%";
+        el.style.width = width.endsWith("px") || width.endsWith("%") ? width : width + "px";
+        el.style.borderRadius = (props.borderRadius || 8) + "px";
+        el.style.display = "block";
+        el.style.margin = "0 auto 8px auto";
+        return el;
+      }
+      case "Button": {
+        const el = document.createElement("button");
+        el.textContent = props.label || "Click";
+        el.style.backgroundColor = sanitizeCssColor(props.bgColor) || "#1B1B1B";
+        el.style.color = sanitizeCssColor(props.textColor) || "#ffffff";
+        el.style.fontSize = (props.fontSize || 16) + "px";
+        el.style.borderRadius = (props.borderRadius || 8) + "px";
+        el.style.border = "none";
+        el.style.padding = "10px 20px";
+        el.style.cursor = "pointer";
+        el.style.fontWeight = "600";
+        el.style.margin = "8px 0";
+        if (props.fullWidth) {
+          el.style.width = "100%";
+        }
+        el.addEventListener("click", () => {
+          const action = props.action || "";
+          if (options.onButtonPress) {
+            options.onButtonPress(action, messageId);
+          } else if (action) {
+            if (isSafeUrl2(action)) {
+              window.location.href = action;
+            }
+          }
+        });
+        return el;
+      }
+      case "Section": {
+        const el = document.createElement("div");
+        if (props.bgColor) el.style.backgroundColor = sanitizeCssColor(props.bgColor) || "";
+        el.style.padding = (props.padding || 16) + "px";
+        el.style.borderRadius = (props.borderRadius || 0) + "px";
+        el.style.margin = "8px 0";
+        if (props.bgImage) {
+          const sanitizedUrl = sanitizeCssUrl(props.bgImage);
+          if (sanitizedUrl) {
+            el.style.backgroundImage = `url("${sanitizedUrl}")`;
+            el.style.backgroundSize = sanitizeBackgroundSize(props.bgSize);
+            el.style.backgroundPosition = "center";
+          }
+        }
+        const children = props.children || [];
+        for (const child of children) {
+          const childEl = this.renderComponent(child, messageId, options);
+          if (childEl) el.appendChild(childEl);
+        }
+        return el;
+      }
+      case "Spacer": {
+        const el = document.createElement("div");
+        el.style.height = (props.height || 24) + "px";
+        return el;
+      }
+      case "Divider": {
+        const el = document.createElement("hr");
+        el.style.border = "none";
+        el.style.borderTop = `${props.thickness || 1}px solid ${sanitizeCssColor(props.color) || "#e5e5e5"}`;
+        el.style.margin = "8px 0";
+        return el;
+      }
+      default:
+        return null;
+    }
+  }
+};
+function isSafeUrl2(url) {
+  try {
+    const parsed = new URL(url, window.location.href);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function sanitizeCssUrl(url) {
+  if (!isSafeUrl2(url)) return null;
+  return url.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "").replace(/\r/g, "");
+}
+function sanitizeTextAlign(value) {
+  const allowed = ["left", "center", "right", "justify"];
+  if (value && allowed.includes(value)) {
+    return value;
+  }
+  return "left";
+}
+function sanitizeBackgroundSize(value) {
+  if (!value) return "cover";
+  const allowed = ["cover", "contain", "auto"];
+  if (allowed.includes(value)) {
+    return value;
+  }
+  const lengthPattern = /^(\d+(\.\d+)?(px|%|em|rem|vh|vw)(\s+\d+(\.\d+)?(px|%|em|rem|vh|vw))?)$/;
+  if (lengthPattern.test(value)) {
+    return value;
+  }
+  return "cover";
+}
+
+// src/index.ts
+var Tolinku = class {
+  constructor(config) {
+    /** The current user ID, used for segment targeting and analytics. */
+    this._userId = null;
+    if (!config.apiKey || typeof config.apiKey !== "string") {
+      throw new Error("Tolinku: apiKey is required and must be a non-empty string");
+    }
+    const resolvedConfig = {
+      ...config,
+      baseUrl: config.baseUrl || "https://api.tolinku.com"
+    };
+    try {
+      const parsed = new URL(resolvedConfig.baseUrl);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("Tolinku: baseUrl must use http: or https: protocol");
+      }
+    } catch (e) {
+      if (e instanceof Error && e.message.startsWith("Tolinku:")) throw e;
+      throw new Error("Tolinku: baseUrl must be a valid URL (e.g. https://api.tolinku.com)");
+    }
+    this.client = new HttpClient(resolvedConfig);
+    this.analytics = new Analytics(this.client);
+    this.referrals = new Referrals(this.client);
+    this.deferred = new Deferred(this.client);
+    this.banners = new Banners(this.client);
+    this.messages = new Messages(this.client);
+  }
+  /**
+   * Set the user ID for segment targeting and analytics attribution.
+   * Pass null to clear the user ID.
+   */
+  setUserId(userId) {
+    this._userId = userId;
+  }
+  /**
+   * Track a custom event (shorthand for analytics.track).
+   * Event type is auto-prefixed with "custom." if not already.
+   * If a userId has been set, it is automatically injected into event properties.
+   */
+  async track(eventType, properties) {
+    const mergedProps = this._userId ? { user_id: this._userId, ...properties } : properties;
+    return this.analytics.track(eventType, mergedProps);
+  }
+  /** Show a smart banner at the top or bottom of the page */
+  async showBanner(options) {
+    return this.banners.show(options, this._userId);
+  }
+  /** Dismiss the currently visible smart banner */
+  dismissBanner() {
+    this.banners.dismiss();
+  }
+  /** Show an in-app message as a modal overlay */
+  async showMessage(options) {
+    return this.messages.show(options, this._userId);
+  }
+  /** Dismiss the currently visible in-app message */
+  dismissMessage() {
+    this.messages.dismiss();
+  }
+  /** Flush any queued analytics events immediately */
+  async flush() {
+    return this.analytics.flush();
+  }
+  /** Clean up all DOM elements, flush events, and cancel in-flight requests (e.g. before unmounting in SPAs) */
+  destroy() {
+    this.analytics.destroy();
+    this.client.abort();
+    this.banners.dismiss();
+    this.messages.dismiss();
+  }
+};
+
+export { Tolinku, TolinkuError };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map