@tolinku/react-native-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,971 @@
+'use strict';
+
+var reactNative = require('react-native');
+var AsyncStorage = require('@react-native-async-storage/async-storage');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var AsyncStorage__default = /*#__PURE__*/_interopDefault(AsyncStorage);
+
+// src/types.ts
+var SDK_VERSION = "0.1.0";
+
+// src/debug.ts
+var _debugEnabled = false;
+function setDebugEnabled(enabled) {
+  _debugEnabled = enabled;
+}
+function debugLog(message) {
+  if (_debugEnabled) {
+    console.log(`[TolinkuSDK] ${message}`);
+  }
+}
+function debugWarn(message) {
+  if (_debugEnabled) {
+    console.warn(`[TolinkuSDK] ${message}`);
+  }
+}
+
+// src/client.ts
+var MAX_RETRIES = 3;
+var BASE_DELAY_MS = 500;
+var MAX_JITTER_MS = 250;
+var HttpClient = class {
+  constructor(config) {
+    /** Set of AbortControllers for in-flight requests. Used by destroy() to cancel all. */
+    this.pendingControllers = /* @__PURE__ */ new Set();
+    this.destroyed = false;
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout;
+  }
+  async get(path, params) {
+    let url = this.baseUrl + path;
+    if (params) {
+      const qs = new URLSearchParams(params).toString();
+      if (qs) url += "?" + qs;
+    }
+    return this.executeWithRetry(url, {
+      method: "GET",
+      headers: this.authenticatedHeaders()
+    });
+  }
+  async post(path, body) {
+    return this.executeWithRetry(this.baseUrl + path, {
+      method: "POST",
+      headers: {
+        ...this.authenticatedHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /** GET without API key auth (for public endpoints like deferred claim) */
+  async getPublic(path, params) {
+    let url = this.baseUrl + path;
+    if (params) {
+      const qs = new URLSearchParams(params).toString();
+      if (qs) url += "?" + qs;
+    }
+    return this.executeWithRetry(url, {
+      method: "GET",
+      headers: this.publicHeaders()
+    });
+  }
+  /** POST without API key auth (for public endpoints like deferred claim) */
+  async postPublic(path, body) {
+    return this.executeWithRetry(this.baseUrl + path, {
+      method: "POST",
+      headers: {
+        ...this.publicHeaders(),
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * Abort all in-flight requests and mark the client as destroyed.
+   * After calling this, all future requests will throw immediately.
+   */
+  abort() {
+    this.destroyed = true;
+    for (const controller of this.pendingControllers) {
+      controller.abort();
+    }
+    this.pendingControllers.clear();
+  }
+  authenticatedHeaders() {
+    return {
+      "X-API-Key": this.apiKey,
+      "Accept": "application/json",
+      "User-Agent": `TolinkuReactNativeSDK/${SDK_VERSION}`
+    };
+  }
+  publicHeaders() {
+    return {
+      "Accept": "application/json",
+      "User-Agent": `TolinkuReactNativeSDK/${SDK_VERSION}`
+    };
+  }
+  /**
+   * Execute a fetch request with retry logic. Retries on:
+   * - Network errors (fetch throws)
+   * - HTTP 429 (Too Many Requests), respecting the Retry-After header
+   * - HTTP 5xx (server errors)
+   *
+   * Does NOT retry on 4xx errors (except 429).
+   * Uses exponential backoff: BASE_DELAY_MS * 2^attempt + random jitter (0..MAX_JITTER_MS).
+   */
+  async executeWithRetry(url, init) {
+    if (this.destroyed) {
+      throw new TolinkuError("Tolinku: client has been destroyed. Call Tolinku.init() to reinitialize.", 0);
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      const controller = new AbortController();
+      this.pendingControllers.add(controller);
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const res = await fetch(url, {
+          ...init,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        this.pendingControllers.delete(controller);
+        if (res.ok) {
+          return res.json();
+        }
+        const errorBody = await res.json().catch(() => ({ error: res.statusText }));
+        const errorMessage = errorBody.error || res.statusText;
+        const errorCode = errorBody.code;
+        const isRetryable = res.status === 429 || res.status >= 500 && res.status < 600;
+        if (!isRetryable || attempt === MAX_RETRIES) {
+          throw new TolinkuError(errorMessage, res.status, errorCode);
+        }
+        lastError = new TolinkuError(errorMessage, res.status, errorCode);
+        let delayMs;
+        if (res.status === 429) {
+          const retryAfter = res.headers.get("Retry-After");
+          const retryAfterSeconds = retryAfter ? parseInt(retryAfter, 10) : NaN;
+          if (!isNaN(retryAfterSeconds) && retryAfterSeconds > 0) {
+            delayMs = retryAfterSeconds * 1e3;
+          } else {
+            delayMs = BASE_DELAY_MS * Math.pow(2, attempt);
+          }
+        } else {
+          delayMs = BASE_DELAY_MS * Math.pow(2, attempt);
+        }
+        const jitter = Math.random() * MAX_JITTER_MS;
+        const totalDelay = delayMs + jitter;
+        debugLog(`Retry ${attempt + 1}/${MAX_RETRIES} after ${Math.round(totalDelay)}ms (status=${res.status})`);
+        await sleep(totalDelay);
+      } catch (err) {
+        clearTimeout(timeoutId);
+        this.pendingControllers.delete(controller);
+        if (this.destroyed) {
+          throw new TolinkuError("Tolinku: request aborted (client destroyed).", 0);
+        }
+        if (err instanceof DOMException && err.name === "AbortError") {
+          const timeoutErr = new TolinkuError(`Tolinku: request timed out after ${this.timeout}ms`, 0);
+          if (attempt === MAX_RETRIES) throw timeoutErr;
+          lastError = timeoutErr;
+        } else if (err instanceof TolinkuError) {
+          throw err;
+        } else {
+          if (attempt === MAX_RETRIES) {
+            throw new TolinkuError(
+              `Tolinku: network error after ${MAX_RETRIES + 1} attempts: ${err.message}`,
+              0
+            );
+          }
+          lastError = err;
+        }
+        const delayMs = BASE_DELAY_MS * Math.pow(2, attempt);
+        const jitter = Math.random() * MAX_JITTER_MS;
+        const totalDelay = delayMs + jitter;
+        debugLog(`Retry ${attempt + 1}/${MAX_RETRIES} after ${Math.round(totalDelay)}ms (${err.message})`);
+        await sleep(totalDelay);
+      }
+    }
+    throw lastError || new TolinkuError("Tolinku: request failed after retries", 0);
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var TolinkuError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.name = "TolinkuError";
+    this.status = status;
+    this.code = code;
+  }
+};
+
+// src/validation.ts
+function isSafeUrl(url) {
+  if (!url || typeof url !== "string") return false;
+  const trimmed = url.trim();
+  if (!trimmed) return false;
+  try {
+    const parsed = new URL(trimmed);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function validateBaseUrl(baseUrl) {
+  if (typeof baseUrl !== "string") {
+    throw new Error("Tolinku: baseUrl must be a non-empty string.");
+  }
+  const trimmed = baseUrl.trim();
+  const isLocalDev = trimmed.startsWith("http://localhost") || trimmed.startsWith("http://127.0.0.1") || trimmed.startsWith("http://10.") || /^http:\/\/172\.(1[6-9]|2\d|3[01])\./.test(trimmed) || trimmed.startsWith("http://192.168.");
+  if (trimmed.startsWith("https://")) {
+    return;
+  }
+  if (isLocalDev) {
+    return;
+  }
+  throw new Error(
+    "Tolinku: baseUrl must use HTTPS to protect your API key. Use https:// instead of http://. Local development URLs (localhost, 127.0.0.1, 10.x, 172.16-31.x, 192.168.x) are exempt from this requirement."
+  );
+}
+var EVENT_NAME_REGEX = /^custom\.[a-z0-9_]+$/;
+function validateEventType(eventType) {
+  if (!eventType || typeof eventType !== "string" || !eventType.trim()) {
+    throw new Error("Tolinku: eventType must be a non-empty string.");
+  }
+  let normalized = eventType.trim();
+  if (!normalized.startsWith("custom.")) {
+    normalized = "custom." + normalized;
+  }
+  if (!EVENT_NAME_REGEX.test(normalized)) {
+    throw new Error(
+      `Tolinku: invalid event type "${normalized}". Event names must match the pattern "custom.[a-z0-9_]+". Use only lowercase letters, digits, and underscores after the "custom." prefix.`
+    );
+  }
+  return normalized;
+}
+
+// src/analytics.ts
+var BATCH_SIZE = 10;
+var FLUSH_INTERVAL_MS = 5e3;
+var MAX_QUEUE_SIZE = 1e3;
+var Analytics = class {
+  constructor(client) {
+    this.queue = [];
+    this.flushTimer = null;
+    this.appStateSubscription = null;
+    this.isFlushing = false;
+    this.handleAppStateChange = (state) => {
+      if (state === "background" || state === "inactive") {
+        this.flush().catch(() => {
+        });
+      }
+    };
+    this.client = client;
+    this.appStateSubscription = reactNative.AppState.addEventListener(
+      "change",
+      this.handleAppStateChange
+    );
+  }
+  /**
+   * Track a custom event. The event is added to the internal queue
+   * and will be flushed automatically or when flush() is called.
+   *
+   * Event type must match /^custom\.[a-z0-9_]+$/.
+   * Auto-prefixes with "custom." if missing.
+   */
+  async track(eventType, properties) {
+    const normalizedType = validateEventType(eventType);
+    const event = {
+      event_type: normalizedType,
+      properties: properties || {}
+    };
+    if (this.queue.length >= MAX_QUEUE_SIZE) {
+      debugWarn(
+        `Analytics queue is full (${MAX_QUEUE_SIZE} events). Dropping oldest event to make room.`
+      );
+      this.queue.shift();
+    }
+    this.queue.push(event);
+    if (this.queue.length >= BATCH_SIZE) {
+      await this.flush();
+    } else if (this.queue.length === 1) {
+      this.startFlushTimer();
+    }
+  }
+  /**
+   * Immediately flush all queued events to the server.
+   * If the queue is empty, this is a no-op.
+   * If a flush is already in progress, this is a no-op to prevent race conditions.
+   */
+  async flush() {
+    if (this.queue.length === 0 || this.isFlushing) return;
+    this.isFlushing = true;
+    const eventsToSend = this.queue.splice(0, this.queue.length);
+    this.cancelFlushTimer();
+    try {
+      debugLog(`Flushing ${eventsToSend.length} analytics event(s)`);
+      const result = await this.client.post("/v1/api/analytics/batch", {
+        events: eventsToSend
+      });
+      if (result.errors && result.errors.length > 0) {
+        debugWarn(`Batch partial failure: ${result.errors.join(", ")}`);
+      }
+    } catch (err) {
+      debugWarn(`Failed to flush analytics events: ${err.message}`);
+      const spaceLeft = MAX_QUEUE_SIZE - this.queue.length;
+      if (spaceLeft > 0) {
+        this.queue.unshift(...eventsToSend.slice(0, spaceLeft));
+      }
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  /**
+   * Shut down the analytics module: flush remaining events, cancel the timer,
+   * and remove the AppState listener.
+   */
+  async destroy() {
+    this.cancelFlushTimer();
+    this.appStateSubscription?.remove();
+    this.appStateSubscription = null;
+    try {
+      await this.flush();
+    } catch {
+    }
+  }
+  startFlushTimer() {
+    this.cancelFlushTimer();
+    this.flushTimer = setTimeout(() => {
+      this.flush().catch((err) => {
+        debugWarn(`Timer flush failed: ${err.message}`);
+      });
+    }, FLUSH_INTERVAL_MS);
+  }
+  cancelFlushTimer() {
+    if (this.flushTimer !== null) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+};
+
+// src/referrals.ts
+var Referrals = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a new referral for a user */
+  async create(options) {
+    if (!options.userId || !options.userId.trim()) {
+      throw new Error("Tolinku: userId is required and must not be blank.");
+    }
+    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) {
+    if (!code || !code.trim()) {
+      throw new Error("Tolinku: referral code is required and must not be blank.");
+    }
+    return this.client.get(`/v1/api/referral/${encodeURIComponent(code)}`);
+  }
+  /** Complete a referral (mark as converted) */
+  async complete(options) {
+    if (!options.code || !options.code.trim()) {
+      throw new Error("Tolinku: referral code is required and must not be blank.");
+    }
+    if (!options.referredUserId || !options.referredUserId.trim()) {
+      throw new Error("Tolinku: referredUserId is required and must not be blank.");
+    }
+    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) {
+    if (!options.code || !options.code.trim()) {
+      throw new Error("Tolinku: referral code is required and must not be blank.");
+    }
+    if (!options.milestone || !options.milestone.trim()) {
+      throw new Error("Tolinku: milestone is required and must not be blank.");
+    }
+    return this.client.post("/v1/api/referral/milestone", {
+      referral_code: options.code,
+      milestone: options.milestone
+    });
+  }
+  /** Claim a referral reward */
+  async claimReward(code) {
+    if (!code || !code.trim()) {
+      throw new Error("Tolinku: referral code is required and must not be blank.");
+    }
+    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)
+    });
+  }
+};
+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) {
+    if (!token || !token.trim()) {
+      throw new Error("Tolinku: token is required and must not be blank for claimByToken.");
+    }
+    try {
+      return await this.client.getPublic("/v1/api/deferred/claim", { token });
+    } catch (err) {
+      debugWarn(`Deferred claimByToken failed: ${err.message}`);
+      return null;
+    }
+  }
+  /** Claim a deferred deep link by device signal matching */
+  async claimBySignals(options) {
+    if (!options.appspaceId || !options.appspaceId.trim()) {
+      throw new Error("Tolinku: appspaceId is required and must not be blank for claimBySignals.");
+    }
+    try {
+      const { width, height } = reactNative.Dimensions.get("screen");
+      const resolvedTimezone = options.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+      const resolvedLanguage = options.language || "en";
+      return await this.client.postPublic("/v1/api/deferred/claim-by-signals", {
+        appspace_id: options.appspaceId,
+        timezone: resolvedTimezone,
+        language: resolvedLanguage,
+        screen_width: options.screenWidth || width,
+        screen_height: options.screenHeight || height
+      });
+    } catch (err) {
+      debugWarn(`Deferred claimBySignals failed: ${err.message}`);
+      return null;
+    }
+  }
+};
+var BASE_KEY = "tolinku_message_dismissed";
+var IMPRESSIONS_BASE_KEY = "tolinku_message_impressions";
+var LAST_SHOWN_BASE_KEY = "tolinku_message_last_shown";
+var keyPrefix = BASE_KEY;
+var impressionsKeyPrefix = IMPRESSIONS_BASE_KEY;
+var lastShownKeyPrefix = LAST_SHOWN_BASE_KEY;
+function setStorageNamespace(apiKey) {
+  const hash = simpleHash(apiKey);
+  keyPrefix = `tolinku_${hash}_message_dismissed`;
+  impressionsKeyPrefix = `tolinku_${hash}_message_impressions`;
+  lastShownKeyPrefix = `tolinku_${hash}_message_last_shown`;
+}
+function resetStorageNamespace() {
+  keyPrefix = BASE_KEY;
+  impressionsKeyPrefix = IMPRESSIONS_BASE_KEY;
+  lastShownKeyPrefix = LAST_SHOWN_BASE_KEY;
+}
+async function getStore(key) {
+  try {
+    const raw = await AsyncStorage__default.default.getItem(key);
+    return raw ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+async function setStore(key, data) {
+  try {
+    await AsyncStorage__default.default.setItem(key, JSON.stringify(data));
+  } catch {
+  }
+}
+async function isMessageDismissed(messageId, dismissDays) {
+  if (!dismissDays || dismissDays <= 0) return false;
+  const data = await getStore(keyPrefix);
+  const entry = data[messageId];
+  if (!entry) return false;
+  const dismissedAt = new Date(entry).getTime();
+  return Date.now() - dismissedAt < dismissDays * 864e5;
+}
+async function saveMessageDismissal(messageId) {
+  const data = await getStore(keyPrefix);
+  data[messageId] = (/* @__PURE__ */ new Date()).toISOString();
+  await setStore(keyPrefix, data);
+}
+async function isMessageSuppressed(messageId, maxImpressions, minIntervalHours) {
+  if (maxImpressions !== null && maxImpressions > 0) {
+    const impressions = await getStore(impressionsKeyPrefix);
+    const count = parseInt(impressions[messageId] || "0", 10);
+    if (count >= maxImpressions) return true;
+  }
+  if (minIntervalHours !== null && minIntervalHours > 0) {
+    const lastShown = await getStore(lastShownKeyPrefix);
+    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;
+}
+async function recordMessageImpression(messageId) {
+  const impressions = await getStore(impressionsKeyPrefix);
+  const count = parseInt(impressions[messageId] || "0", 10);
+  impressions[messageId] = String(count + 1);
+  await setStore(impressionsKeyPrefix, impressions);
+  const lastShown = await getStore(lastShownKeyPrefix);
+  lastShown[messageId] = (/* @__PURE__ */ new Date()).toISOString();
+  await setStore(lastShownKeyPrefix, lastShown);
+}
+function simpleHash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i) & 4294967295;
+  }
+  return (hash >>> 0).toString(16);
+}
+
+// src/Tolinku.ts
+var _Tolinku = class _Tolinku {
+  /**
+   * Initialize the SDK. Must be called before any other method.
+   *
+   * If init() is called a second time without calling destroy() first,
+   * a warning is logged and the existing instance is returned.
+   */
+  static init(config) {
+    if (!config.apiKey) throw new Error("Tolinku: apiKey is required");
+    if (_Tolinku._initialized) {
+      debugWarn(
+        "Tolinku.init() called while already initialized. Call Tolinku.destroy() first if you need to reconfigure."
+      );
+      console.warn(
+        "[TolinkuSDK] init() called while already initialized. Call Tolinku.destroy() first if you need to reconfigure."
+      );
+      return;
+    }
+    const baseUrl = config.baseUrl || "https://api.tolinku.com";
+    validateBaseUrl(baseUrl);
+    setDebugEnabled(config.debug === true);
+    const resolvedConfig = {
+      apiKey: config.apiKey,
+      baseUrl,
+      debug: config.debug === true,
+      timeout: config.timeout ?? 3e4
+    };
+    setStorageNamespace(config.apiKey);
+    _Tolinku.client = new HttpClient(resolvedConfig);
+    _Tolinku.analyticsInstance = new Analytics(_Tolinku.client);
+    _Tolinku.referralsInstance = new Referrals(_Tolinku.client);
+    _Tolinku.deferredInstance = new Deferred(_Tolinku.client);
+    _Tolinku._initialized = true;
+    debugLog(`Tolinku SDK v${SDK_VERSION} initialized (baseUrl=${baseUrl})`);
+  }
+  /** Check whether the SDK has been initialized. */
+  static isConfigured() {
+    return _Tolinku._initialized;
+  }
+  /**
+   * Set the user ID for segment targeting and analytics attribution.
+   * Pass null to clear the user ID.
+   */
+  static setUserId(userId) {
+    _Tolinku._userId = userId;
+  }
+  /** Get the current user ID, or null if not set. */
+  static getUserId() {
+    return _Tolinku._userId;
+  }
+  /** Get the underlying HTTP client (used internally by MessageProvider) */
+  static getClient() {
+    if (!_Tolinku.client) {
+      throw new Error("Tolinku: SDK not initialized. Call Tolinku.init() first.");
+    }
+    return _Tolinku.client;
+  }
+  /**
+   * Track a custom event (shorthand for analytics.track).
+   * Event type is auto-prefixed with "custom." if not already.
+   * Events are batched and flushed automatically.
+   */
+  static async track(eventType, properties) {
+    if (!_Tolinku.analyticsInstance) {
+      throw new Error("Tolinku: SDK not initialized. Call Tolinku.init() first.");
+    }
+    const mergedProps = _Tolinku._userId ? { user_id: _Tolinku._userId, ...properties } : properties;
+    return _Tolinku.analyticsInstance.track(eventType, mergedProps);
+  }
+  /**
+   * Immediately flush all queued analytics events to the server.
+   */
+  static async flush() {
+    if (!_Tolinku.analyticsInstance) {
+      throw new Error("Tolinku: SDK not initialized. Call Tolinku.init() first.");
+    }
+    return _Tolinku.analyticsInstance.flush();
+  }
+  /** Referrals: create, complete, milestone, leaderboard, claimReward */
+  static get referrals() {
+    if (!_Tolinku.referralsInstance) {
+      throw new Error("Tolinku: SDK not initialized. Call Tolinku.init() first.");
+    }
+    return _Tolinku.referralsInstance;
+  }
+  /** Deferred deep links: claimByToken, claimBySignals */
+  static get deferred() {
+    if (!_Tolinku.deferredInstance) {
+      throw new Error("Tolinku: SDK not initialized. Call Tolinku.init() first.");
+    }
+    return _Tolinku.deferredInstance;
+  }
+  /**
+   * Shut down the SDK and release resources.
+   * Flushes remaining analytics events, cancels timers, removes listeners,
+   * and aborts in-flight requests. After calling this, you must call init()
+   * again before using the SDK.
+   */
+  static async destroy() {
+    debugLog("Tolinku SDK shutting down");
+    if (_Tolinku.analyticsInstance) {
+      await _Tolinku.analyticsInstance.destroy();
+    }
+    if (_Tolinku.client) {
+      _Tolinku.client.abort();
+    }
+    resetStorageNamespace();
+    _Tolinku.client = null;
+    _Tolinku.analyticsInstance = null;
+    _Tolinku.referralsInstance = null;
+    _Tolinku.deferredInstance = null;
+    _Tolinku._initialized = false;
+    _Tolinku._userId = null;
+    setDebugEnabled(false);
+  }
+};
+_Tolinku.VERSION = SDK_VERSION;
+_Tolinku.client = null;
+_Tolinku.analyticsInstance = null;
+_Tolinku.referralsInstance = null;
+_Tolinku.deferredInstance = null;
+_Tolinku._initialized = false;
+_Tolinku._userId = null;
+var Tolinku = _Tolinku;
+function PuckComponentRenderer({ component, messageId, options }) {
+  const { props } = component;
+  switch (component.type) {
+    case "Heading": {
+      const style = {
+        fontSize: props.fontSize || 28,
+        fontWeight: "700",
+        color: props.color || "#1B1B1B",
+        textAlign: props.alignment || "left",
+        lineHeight: (props.fontSize || 28) * 1.2,
+        marginBottom: 8
+      };
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style, children: props.text || "" });
+    }
+    case "TextBlock": {
+      const style = {
+        fontSize: props.fontSize || 15,
+        color: props.color || "#555555",
+        textAlign: props.alignment || "left",
+        lineHeight: (props.fontSize || 15) * 1.5,
+        marginBottom: 8
+      };
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style, children: props.content || "" });
+    }
+    case "Image": {
+      const imageUrl = props.url || "";
+      if (!imageUrl || !imageUrl.trim()) {
+        debugWarn("Image component has empty URL, skipping render.");
+        return null;
+      }
+      if (!isSafeUrl(imageUrl)) {
+        debugWarn(`Image URL blocked (unsafe protocol): ${imageUrl}`);
+        return null;
+      }
+      const widthRaw = props.width || "100%";
+      let imageWidth = "100%";
+      if (widthRaw.endsWith("px")) {
+        imageWidth = parseInt(widthRaw, 10);
+      } else if (widthRaw.endsWith("%")) {
+        imageWidth = widthRaw;
+      } else {
+        const parsed = parseInt(widthRaw, 10);
+        imageWidth = isNaN(parsed) ? "100%" : parsed;
+      }
+      const style = {
+        width: imageWidth,
+        height: props.height || 200,
+        borderRadius: props.borderRadius || 8,
+        alignSelf: "center",
+        marginBottom: 8
+      };
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.Image,
+        {
+          source: { uri: imageUrl },
+          style,
+          resizeMode: "cover",
+          accessibilityLabel: props.alt || ""
+        }
+      );
+    }
+    case "Button": {
+      const handlePress = () => {
+        const action = props.action || "";
+        if (options.onButtonPress) {
+          options.onButtonPress(action, messageId);
+        } else if (action) {
+          if (!isSafeUrl(action)) {
+            debugWarn(`Button action URL blocked (unsafe protocol): ${action}`);
+            return;
+          }
+          reactNative.Linking.openURL(action).catch(() => {
+          });
+        }
+      };
+      const containerStyle = {
+        backgroundColor: props.bgColor || "#1B1B1B",
+        borderRadius: props.borderRadius || 8,
+        paddingVertical: 10,
+        paddingHorizontal: 20,
+        marginVertical: 8,
+        alignItems: "center",
+        ...props.fullWidth ? { width: "100%" } : {}
+      };
+      const textStyle = {
+        color: props.textColor || "#ffffff",
+        fontSize: props.fontSize || 16,
+        fontWeight: "600"
+      };
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.TouchableOpacity, { onPress: handlePress, style: containerStyle, activeOpacity: 0.7, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: textStyle, children: props.label || "Click" }) });
+    }
+    case "Section": {
+      const children = props.children || [];
+      const containerStyle = {
+        backgroundColor: props.bgColor || void 0,
+        padding: props.padding || 16,
+        borderRadius: props.borderRadius || 0,
+        marginVertical: 8
+      };
+      const bgImage = props.bgImage || "";
+      const content = children.map((child, index) => /* @__PURE__ */ jsxRuntime.jsx(
+        PuckComponentRenderer,
+        {
+          component: child,
+          messageId,
+          options
+        },
+        `${messageId}-section-${index}-${child.type}`
+      ));
+      if (bgImage) {
+        if (!isSafeUrl(bgImage)) {
+          debugWarn(`Section background image URL blocked (unsafe protocol): ${bgImage}`);
+          return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: containerStyle, children: content });
+        }
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.ImageBackground,
+          {
+            source: { uri: bgImage },
+            style: containerStyle,
+            resizeMode: props.bgSize === "contain" ? "contain" : "cover",
+            imageStyle: { borderRadius: props.borderRadius || 0 },
+            children: content
+          }
+        );
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: containerStyle, children: content });
+    }
+    case "Spacer": {
+      const style = {
+        height: props.height || 24
+      };
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style });
+    }
+    case "Divider": {
+      const style = {
+        borderTopWidth: props.thickness || 1,
+        borderTopColor: props.color || "#e5e5e5",
+        marginVertical: 8
+      };
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style });
+    }
+    default:
+      return null;
+  }
+}
+function MessageModal({ message, visible, onClose, options }) {
+  if (!message) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, {});
+  }
+  const handleDismiss = async () => {
+    await saveMessageDismissal(message.id);
+    options.onDismiss?.(message.id);
+    onClose();
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Modal,
+    {
+      visible,
+      transparent: true,
+      animationType: "fade",
+      onRequestClose: handleDismiss,
+      children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { style: styles.overlay, onPress: handleDismiss, children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Pressable, { style: [styles.card, { backgroundColor: message.background_color || "#ffffff" }], onPress: () => {
+      }, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.TouchableOpacity,
+          {
+            onPress: handleDismiss,
+            style: styles.closeButton,
+            accessibilityLabel: "Close message",
+            accessibilityRole: "button",
+            children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles.closeText, children: "\xD7" })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.ScrollView,
+          {
+            style: styles.scrollContent,
+            showsVerticalScrollIndicator: false,
+            children: message.content?.content?.map((component, index) => /* @__PURE__ */ jsxRuntime.jsx(
+              PuckComponentRenderer,
+              {
+                component,
+                messageId: message.id,
+                options
+              },
+              `${message.id}-${index}-${component.type}`
+            ))
+          }
+        )
+      ] }) })
+    }
+  );
+}
+var styles = reactNative.StyleSheet.create({
+  overlay: {
+    flex: 1,
+    backgroundColor: "rgba(0,0,0,0.5)",
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  card: {
+    position: "relative",
+    maxWidth: 375,
+    width: "90%",
+    maxHeight: "80%",
+    borderRadius: 16,
+    padding: 24,
+    shadowColor: "#000",
+    shadowOffset: { width: 0, height: 20 },
+    shadowOpacity: 0.3,
+    shadowRadius: 30,
+    elevation: 10
+  },
+  closeButton: {
+    position: "absolute",
+    top: 12,
+    right: 12,
+    zIndex: 10,
+    backgroundColor: "rgba(0,0,0,0.1)",
+    borderRadius: 14,
+    width: 28,
+    height: 28,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  closeText: {
+    fontSize: 18,
+    lineHeight: 20,
+    opacity: 0.6
+  },
+  scrollContent: {
+    marginTop: 8
+  }
+});
+function TolinkuMessages({
+  trigger,
+  triggerValue,
+  onDismiss,
+  onButtonPress
+}) {
+  const [message, setMessage] = react.useState(null);
+  const [visible, setVisible] = react.useState(false);
+  const onDismissRef = react.useRef(onDismiss);
+  onDismissRef.current = onDismiss;
+  const onButtonPressRef = react.useRef(onButtonPress);
+  onButtonPressRef.current = onButtonPress;
+  const options = react.useMemo(() => ({
+    trigger,
+    triggerValue,
+    onDismiss: (messageId) => onDismissRef.current?.(messageId),
+    onButtonPress: (action, messageId) => onButtonPressRef.current?.(action, messageId)
+  }), [trigger, triggerValue]);
+  react.useEffect(() => {
+    let cancelled = false;
+    async function fetchMessages() {
+      try {
+        const client = Tolinku.getClient();
+        const params = {};
+        if (trigger) params.trigger = trigger;
+        const userId = Tolinku.getUserId();
+        if (userId) params.user_id = userId;
+        const data = await client.get("/v1/api/messages", params);
+        if (cancelled || !data.messages || data.messages.length === 0) return;
+        const candidates = [];
+        for (const m of data.messages) {
+          if (triggerValue && m.trigger_value !== triggerValue) continue;
+          const dismissed = await isMessageDismissed(m.id, m.dismiss_days);
+          if (dismissed) continue;
+          const suppressed = await isMessageSuppressed(m.id, m.max_impressions, m.min_interval_hours);
+          if (!suppressed) candidates.push(m);
+        }
+        candidates.sort((a, b) => b.priority - a.priority);
+        if (candidates.length > 0 && !cancelled) {
+          await recordMessageImpression(candidates[0].id);
+          setMessage(candidates[0]);
+          setVisible(true);
+        }
+      } catch (err) {
+        debugWarn(`Failed to fetch messages: ${err.message}`);
+      }
+    }
+    fetchMessages();
+    return () => {
+      cancelled = true;
+    };
+  }, [trigger, triggerValue]);
+  const handleClose = react.useCallback(() => {
+    setVisible(false);
+    setMessage(null);
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    MessageModal,
+    {
+      message,
+      visible,
+      onClose: handleClose,
+      options
+    }
+  );
+}
+
+exports.Tolinku = Tolinku;
+exports.TolinkuError = TolinkuError;
+exports.TolinkuMessages = TolinkuMessages;
+exports.isSafeUrl = isSafeUrl;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map