@encatch/react-native-sdk 1.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,1910 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Encatch: () => Encatch,
+  EncatchProvider: () => EncatchProvider,
+  EncatchWebView: () => EncatchWebView,
+  buildSubmitRequest: () => buildSubmitRequest,
+  useEncatch: () => useEncatch
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/emitter.ts
+var TypedEmitter = class {
+  constructor() {
+    this._listeners = {};
+  }
+  on(event, listener) {
+    if (!this._listeners[event]) {
+      this._listeners[event] = [];
+    }
+    this._listeners[event].push(listener);
+  }
+  off(event, listener) {
+    const listeners = this._listeners[event];
+    if (!listeners) return;
+    const idx = listeners.indexOf(listener);
+    if (idx !== -1) listeners.splice(idx, 1);
+  }
+  emit(event, payload) {
+    const listeners = this._listeners[event];
+    if (!listeners) return;
+    for (const listener of [...listeners]) {
+      try {
+        listener(payload);
+      } catch (e) {
+      }
+    }
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this._listeners[event] = [];
+    } else {
+      this._listeners = {};
+    }
+  }
+};
+
+// src/storage.ts
+var import_async_storage = __toESM(require("@react-native-async-storage/async-storage"));
+var import_uuidv7 = require("uuidv7");
+var KEY_DEVICE_ID = "@encatch/device_id";
+var KEY_USER_NAME = "@encatch/user_name";
+var KEY_USER_ID_PREFIX = "@encatch/user_id_";
+var KEY_FT_PREFIX = "@encatch/ft_";
+var KEY_PREFERENCES = "@encatch/preferences";
+async function getOrCreateDeviceId() {
+  try {
+    const stored = await import_async_storage.default.getItem(KEY_DEVICE_ID);
+    if (stored) return stored;
+    const id = (0, import_uuidv7.uuidv7)();
+    await import_async_storage.default.setItem(KEY_DEVICE_ID, id);
+    return id;
+  } catch (e) {
+    return (0, import_uuidv7.uuidv7)();
+  }
+}
+var inMemorySessionId = null;
+async function getOrCreateSessionId() {
+  if (inMemorySessionId) return inMemorySessionId;
+  inMemorySessionId = (0, import_uuidv7.uuidv7)();
+  return inMemorySessionId;
+}
+async function clearSession() {
+  inMemorySessionId = null;
+}
+async function getUserName() {
+  try {
+    return await import_async_storage.default.getItem(KEY_USER_NAME);
+  } catch (e) {
+    return null;
+  }
+}
+async function setUserName(name) {
+  try {
+    await import_async_storage.default.setItem(KEY_USER_NAME, name);
+  } catch (e) {
+  }
+}
+async function clearUserName() {
+  try {
+    await import_async_storage.default.removeItem(KEY_USER_NAME);
+  } catch (e) {
+  }
+}
+async function getUserId(userName) {
+  try {
+    return await import_async_storage.default.getItem(`${KEY_USER_ID_PREFIX}${userName}`);
+  } catch (e) {
+    return null;
+  }
+}
+async function setUserId(userName, userId) {
+  try {
+    await import_async_storage.default.setItem(`${KEY_USER_ID_PREFIX}${userName}`, userId);
+  } catch (e) {
+  }
+}
+async function clearUserId(userName) {
+  try {
+    await import_async_storage.default.removeItem(`${KEY_USER_ID_PREFIX}${userName}`);
+  } catch (e) {
+  }
+}
+function ftKey(identityKey) {
+  return `${KEY_FT_PREFIX}${identityKey}`;
+}
+async function getFeedbackTransactions(identityKey) {
+  try {
+    return await import_async_storage.default.getItem(ftKey(identityKey));
+  } catch (e) {
+    return null;
+  }
+}
+async function setFeedbackTransactions(identityKey, value) {
+  try {
+    await import_async_storage.default.setItem(ftKey(identityKey), value);
+  } catch (e) {
+  }
+}
+async function clearFeedbackTransactions(identityKey) {
+  try {
+    await import_async_storage.default.removeItem(ftKey(identityKey));
+  } catch (e) {
+  }
+}
+async function getPreferences() {
+  try {
+    const raw = await import_async_storage.default.getItem(KEY_PREFERENCES);
+    return raw ? JSON.parse(raw) : {};
+  } catch (e) {
+    return {};
+  }
+}
+async function setPreferences(updates) {
+  try {
+    const current = await getPreferences();
+    await import_async_storage.default.setItem(KEY_PREFERENCES, JSON.stringify(__spreadValues(__spreadValues({}, current), updates)));
+  } catch (e) {
+  }
+}
+async function clearPreferences() {
+  try {
+    await import_async_storage.default.removeItem(KEY_PREFERENCES);
+  } catch (e) {
+  }
+}
+
+// src/device-info.ts
+var import_react_native = require("react-native");
+async function getDeviceLocale() {
+  var _a, _b, _c, _d;
+  try {
+    const Localization = require("expo-localization");
+    const locales = (_a = Localization.getLocales) == null ? void 0 : _a.call(Localization);
+    if (Array.isArray(locales) && locales.length > 0 && ((_b = locales[0]) == null ? void 0 : _b.languageTag)) {
+      return locales[0].languageTag;
+    }
+  } catch (e) {
+  }
+  try {
+    const RNLocalize = require("react-native-localize");
+    const locales = (_c = RNLocalize.getLocales) == null ? void 0 : _c.call(RNLocalize);
+    if (Array.isArray(locales) && locales.length > 0 && ((_d = locales[0]) == null ? void 0 : _d.languageTag)) {
+      return locales[0].languageTag;
+    }
+  } catch (e) {
+  }
+  return "en";
+}
+function getOsVersion() {
+  const v = import_react_native.Platform.Version;
+  if (typeof v === "number") return String(v);
+  return v != null ? v : "unknown";
+}
+async function getAppVersion() {
+  var _a;
+  try {
+    const Application = require("expo-application");
+    const v = Application.nativeApplicationVersion;
+    if (v && typeof v === "string") return v;
+  } catch (e) {
+  }
+  try {
+    const DeviceInfo = require("react-native-device-info");
+    const v = (_a = DeviceInfo.getVersion) == null ? void 0 : _a.call(DeviceInfo);
+    if (v && typeof v === "string") return v;
+  } catch (e) {
+  }
+  return null;
+}
+async function getAppPackageId() {
+  var _a, _b, _c;
+  let isExpo = false;
+  try {
+    const Device = require("expo-device");
+    isExpo = typeof Device.getDeviceTypeAsync === "function";
+  } catch (e) {
+  }
+  if (isExpo) {
+    try {
+      const Application = require("expo-application");
+      let id = Application.applicationId;
+      if (!id && typeof Application.getApplicationIdAsync === "function") {
+        id = await Application.getApplicationIdAsync();
+      }
+      if (id && typeof id === "string") return id;
+    } catch (e) {
+    }
+    try {
+      const Constants = require("expo-constants");
+      const env = (_b = (_a = Constants == null ? void 0 : Constants.default) == null ? void 0 : _a.executionEnvironment) != null ? _b : Constants == null ? void 0 : Constants.executionEnvironment;
+      if (env === "storeClient") return "expo-go";
+    } catch (e) {
+    }
+    return "expo-go";
+  }
+  try {
+    const DeviceInfo = require("react-native-device-info");
+    const id = (_c = DeviceInfo.getBundleId) == null ? void 0 : _c.call(DeviceInfo);
+    if (id && typeof id === "string") return id;
+  } catch (e) {
+  }
+  return null;
+}
+function getTimezone() {
+  try {
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    if (tz && typeof tz === "string") return tz;
+  } catch (e) {
+  }
+  return null;
+}
+function getPlatform() {
+  if (import_react_native.Platform.OS === "ios") return "ios";
+  if (import_react_native.Platform.OS === "android") return "android";
+  return "web";
+}
+function getDeviceTypeEnv() {
+  return getPlatform() === "web" ? "web" : "native";
+}
+function getDeviceSize() {
+  const g = globalThis;
+  if (typeof g.window === "undefined" || typeof g.window.innerWidth !== "number") {
+    return void 0;
+  }
+  const w = g.window.innerWidth;
+  if (w < 768) return "mobile";
+  if (w < 1024) return "tablet";
+  return "desktop";
+}
+
+// src/retry-queue.ts
+var import_react_native2 = require("react-native");
+var import_async_storage2 = __toESM(require("@react-native-async-storage/async-storage"));
+var QUEUE_KEY = "@encatch/retry_queue";
+var MAX_RETRIES = 3;
+var BASE_BACKOFF_MS = 1e3;
+var queue = [];
+function isClientError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const match = msg.match(/status (\d+)/);
+  if (!match) return false;
+  const status = parseInt(match[1], 10);
+  return status >= 400 && status < 500;
+}
+function backoffMs(retries) {
+  return BASE_BACKOFF_MS * Math.pow(2, retries);
+}
+async function persistQueue() {
+  try {
+    const serializable = queue.map((item) => ({
+      id: item.id,
+      retries: item.retries,
+      maxRetries: item.maxRetries,
+      createdAt: item.createdAt,
+      label: item.label
+    }));
+    await import_async_storage2.default.setItem(QUEUE_KEY, JSON.stringify(serializable));
+  } catch (e) {
+  }
+}
+async function removeFromPersisted(id) {
+  try {
+    const raw = await import_async_storage2.default.getItem(QUEUE_KEY);
+    if (!raw) return;
+    const items = JSON.parse(raw);
+    const filtered = items.filter((i) => i.id !== id);
+    await import_async_storage2.default.setItem(QUEUE_KEY, JSON.stringify(filtered));
+  } catch (e) {
+  }
+}
+function enqueue(label, fn, maxRetries = MAX_RETRIES) {
+  const item = {
+    id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    fn,
+    retries: 0,
+    maxRetries,
+    createdAt: Date.now(),
+    label
+  };
+  queue.push(item);
+  persistQueue();
+}
+async function flush() {
+  if (queue.length === 0) return;
+  const snapshot = [...queue];
+  for (const item of snapshot) {
+    try {
+      await item.fn();
+      const idx = queue.findIndex((q) => q.id === item.id);
+      if (idx !== -1) queue.splice(idx, 1);
+      await removeFromPersisted(item.id);
+    } catch (err) {
+      if (isClientError(err)) {
+        const idx = queue.findIndex((q) => q.id === item.id);
+        if (idx !== -1) queue.splice(idx, 1);
+        await removeFromPersisted(item.id);
+        console.warn(`[Encatch] Retry queue: dropping "${item.label}" (client error, no retry)`, err);
+        return;
+      }
+      item.retries += 1;
+      if (item.retries >= item.maxRetries) {
+        const idx = queue.findIndex((q) => q.id === item.id);
+        if (idx !== -1) queue.splice(idx, 1);
+        await removeFromPersisted(item.id);
+        console.warn(`[Encatch] Retry queue: dropping "${item.label}" after ${item.maxRetries} retries`, err);
+      } else {
+        const delay = backoffMs(item.retries);
+        setTimeout(() => flushSingle(item.id), delay);
+        await persistQueue();
+      }
+    }
+  }
+}
+async function flushSingle(id) {
+  const item = queue.find((q) => q.id === id);
+  if (!item) return;
+  try {
+    await item.fn();
+    const idx = queue.findIndex((q) => q.id === id);
+    if (idx !== -1) queue.splice(idx, 1);
+    await removeFromPersisted(id);
+  } catch (err) {
+    if (isClientError(err)) {
+      const idx = queue.findIndex((q) => q.id === id);
+      if (idx !== -1) queue.splice(idx, 1);
+      await removeFromPersisted(id);
+      console.warn(`[Encatch] Retry queue: dropping "${item.label}" (client error, no retry)`, err);
+      return;
+    }
+    item.retries += 1;
+    if (item.retries >= item.maxRetries) {
+      const idx = queue.findIndex((q) => q.id === id);
+      if (idx !== -1) queue.splice(idx, 1);
+      await removeFromPersisted(id);
+      console.warn(`[Encatch] Retry queue: dropping "${item.label}" after ${item.maxRetries} retries`, err);
+    } else {
+      const delay = backoffMs(item.retries);
+      setTimeout(() => flushSingle(id), delay);
+      await persistQueue();
+    }
+  }
+}
+var appStateSubscription = null;
+function startAppStateListener() {
+  if (appStateSubscription) return;
+  const handleAppStateChange = (nextState) => {
+    if (nextState === "active") {
+      flush().catch(() => {
+      });
+    }
+  };
+  appStateSubscription = import_react_native2.AppState.addEventListener("change", handleAppStateChange);
+}
+function stopAppStateListener() {
+  if (appStateSubscription) {
+    appStateSubscription.remove();
+    appStateSubscription = null;
+  }
+}
+
+// src/logger.ts
+var noop = () => {
+};
+function createFallbackLogger(debugMode) {
+  return {
+    debug: debugMode ? (...args) => console.log("[Encatch]", ...args) : noop,
+    warn: (...args) => console.warn("[Encatch]", ...args)
+  };
+}
+function prettyStringify(msg) {
+  if (msg === null) return "null";
+  if (msg === void 0) return "undefined";
+  if (typeof msg === "string") {
+    try {
+      const parsed = JSON.parse(msg);
+      return JSON.stringify(parsed, null, 2);
+    } catch (e) {
+      return msg;
+    }
+  }
+  if (typeof msg === "object") {
+    return JSON.stringify(msg, null, 2);
+  }
+  return String(msg);
+}
+function createEncatchLogger(debugMode) {
+  try {
+    const { logger, consoleTransport } = require("react-native-logs");
+    const encatchLog = logger.createLogger({
+      levels: { debug: 0, info: 1, warn: 2, error: 3 },
+      severity: debugMode ? "debug" : "warn",
+      transport: consoleTransport,
+      transportOptions: {
+        colors: {
+          debug: "cyan",
+          info: "blueBright",
+          warn: "yellowBright",
+          error: "redBright"
+        }
+      },
+      stringifyFunc: (msg) => {
+        if (Array.isArray(msg)) {
+          return msg.map((m) => prettyStringify(m)).join("\n");
+        }
+        return prettyStringify(msg);
+      },
+      dateFormat: "time",
+      printLevel: true,
+      printDate: true,
+      enabled: true
+    });
+    const ext = encatchLog.extend("Encatch");
+    return {
+      debug: (...args) => ext.debug(...args),
+      warn: (...args) => ext.warn(...args)
+    };
+  } catch (e) {
+    return createFallbackLogger(debugMode);
+  }
+}
+
+// src/encatch.ts
+var SDK_VERSION = "2.0.0";
+var ENDPOINTS = {
+  IDENTIFY_USER: "engage-product/encatch/api/v2/encatch/identify-user",
+  TRACK_EVENT: "engage-product/encatch/api/v2/encatch/track-event",
+  TRACK_SCREEN: "engage-product/encatch/api/v2/encatch/track-screen",
+  SHOW_FORM: "engage-product/encatch/api/v2/encatch/show-form",
+  DISMISS_FORM: "engage-product/encatch/api/v2/encatch/dismiss-form",
+  PING: "engage-product/encatch/api/v2/encatch/ping",
+  REFINE_TEXT: "engage-product/encatch/api/v2/encatch/refine-text",
+  SUBMIT_FORM: "engage-product/encatch/api/v2/encatch/submit-form"
+};
+var _internalEmitter = new TypedEmitter();
+var EncatchSDK = class {
+  constructor() {
+    // Initialisation state
+    this._initialized = false;
+    this._debugMode = false;
+    // Config
+    this._apiKey = null;
+    this._apiBaseUrl = "https://app.encatch.com";
+    this._webHost = "https://app.encatch.com";
+    this._isFullScreen = false;
+    // Identity
+    this._userName = null;
+    this._userId = null;
+    this._userSignature = null;
+    // Preferences
+    this._locale = null;
+    this._country = null;
+    this._theme = "system";
+    // Current screen (updated by EncatchProvider / trackScreen)
+    this._currentScreen = null;
+    // Async-loaded ids (populated after init)
+    this._deviceId = null;
+    this._sessionId = null;
+    // Feedback transactions (persisted opaque string returned by API)
+    this._feedbackTransactions = null;
+    // Ping interval
+    this._pingIntervalId = null;
+    this._pingTimeoutId = null;
+    this._pingIntervalMs = 3e4;
+    this._isPingActive = false;
+    // Whether a form is currently visible (suppresses ping)
+    this._isFormVisible = false;
+    // App version (can be set by consumer)
+    this._appVersion = "1.0.0";
+    this._appPackageName = null;
+    // Event callbacks (external SDK consumers via Encatch.on())
+    this._eventCallbacks = [];
+    // Interceptor (optional — called before showing any form)
+    this._onBeforeShowForm = void 0;
+    // Logger (uses react-native-logs when debugMode and package installed)
+    this._logger = createEncatchLogger(false);
+    // ============================================================================
+    // Form response helpers
+    // ============================================================================
+    // Pre-filled responses stored by addToResponse, sent with sdk:prefillResponses
+    this._pendingResponses = {};
+  }
+  // ============================================================================
+  // Initialisation
+  // ============================================================================
+  async init(apiKey, config) {
+    var _a, _b, _c, _d, _e, _f;
+    this._debugMode = (_a = config == null ? void 0 : config.debugMode) != null ? _a : false;
+    this._logger = createEncatchLogger(this._debugMode);
+    if (this._initialized) {
+      this._logger.debug("SDK already initialized");
+      return;
+    }
+    this._apiKey = apiKey;
+    const defaultHost = "https://app.encatch.com";
+    this._apiBaseUrl = ((_b = config == null ? void 0 : config.apiBaseUrl) != null ? _b : defaultHost).replace(/\/+$/, "");
+    this._webHost = ((_c = config == null ? void 0 : config.webHost) != null ? _c : this._apiBaseUrl).replace(/\/+$/, "");
+    this._isFullScreen = (_d = config == null ? void 0 : config.isFullScreen) != null ? _d : false;
+    if (config == null ? void 0 : config.theme) {
+      this._theme = config.theme;
+    }
+    this._onBeforeShowForm = config == null ? void 0 : config.onBeforeShowForm;
+    this._logger.debug("Initializing SDK...");
+    const [storedName, deviceId, sessionId, prefs, appPackageId, appVersion] = await Promise.all([
+      getUserName(),
+      getOrCreateDeviceId(),
+      getOrCreateSessionId(),
+      getPreferences(),
+      getAppPackageId(),
+      getAppVersion()
+    ]);
+    this._deviceId = deviceId;
+    this._sessionId = sessionId;
+    this._appPackageName = appPackageId != null ? appPackageId : null;
+    this._appVersion = (_f = (_e = config == null ? void 0 : config.appVersion) != null ? _e : appVersion) != null ? _f : "1.0.0";
+    if (prefs.locale != null) this._locale = prefs.locale;
+    if (prefs.country != null) this._country = prefs.country;
+    if (storedName) {
+      this._userName = storedName;
+      this._userId = await getUserId(storedName);
+      this._feedbackTransactions = await getFeedbackTransactions(storedName);
+    } else {
+      this._feedbackTransactions = await getFeedbackTransactions("anonymous");
+    }
+    this._initialized = true;
+    startAppStateListener();
+    flush().catch(() => {
+    });
+    this._logger.debug("SDK initialized. deviceId:", deviceId);
+  }
+  // ============================================================================
+  // Identity
+  // ============================================================================
+  async identifyUser(userName, traits, options) {
+    var _a, _b, _c, _d, _e;
+    if (!this._initialized) return;
+    this._userName = userName;
+    await setUserName(userName);
+    if ((options == null ? void 0 : options.locale) != null) {
+      this._locale = options.locale;
+      setPreferences({ locale: options.locale }).catch(() => {
+      });
+    }
+    if ((options == null ? void 0 : options.country) != null) {
+      this._country = options.country;
+      setPreferences({ country: options.country }).catch(() => {
+      });
+    }
+    const convertDates = (obj) => {
+      if (!obj) return void 0;
+      return Object.keys(obj).reduce((acc, k) => {
+        acc[k] = obj[k] instanceof Date ? obj[k].toISOString() : obj[k];
+        return acc;
+      }, {});
+    };
+    const userAttributes = traits ? __spreadProps(__spreadValues({}, traits), {
+      $set: convertDates(traits.$set),
+      $setOnce: convertDates(traits.$setOnce)
+    }) : void 0;
+    const deviceInfo = await this._buildDeviceInfo();
+    const req = {
+      userName,
+      userId: (_a = this._userId) != null ? _a : void 0,
+      userSignature: (_d = (_c = (_b = options == null ? void 0 : options.secure) == null ? void 0 : _b.signature) != null ? _c : this._userSignature) != null ? _d : void 0,
+      $deviceInfo: deviceInfo,
+      userAttributes,
+      $feedbackTransactions: (_e = this._feedbackTransactions) != null ? _e : void 0
+    };
+    enqueue("identifyUser", async () => {
+      var _a2;
+      const res = await this._post(ENDPOINTS.IDENTIFY_USER, req, {
+        signatureTime: (_a2 = options == null ? void 0 : options.secure) == null ? void 0 : _a2.generatedDateTimeinUTC
+      });
+      if (res.userId) {
+        this._userId = res.userId;
+        await setUserId(userName, res.userId);
+      }
+      if (res.$feedbackTransactions) {
+        this._feedbackTransactions = res.$feedbackTransactions;
+        await setFeedbackTransactions(userName, res.$feedbackTransactions);
+      }
+      this._handleResponseMeta(res);
+      _internalEmitter.emit("userIdentified", {
+        userName: this._userName,
+        userId: this._userId
+      });
+      await this.startSession({ skipImmediatePing: true, skipImmediateTrackScreen: true });
+      if (typeof res.pingAgainIn === "number" && res.pingAgainIn > 0) {
+        this._scheduleNextPing(res.pingAgainIn * 1e3);
+      }
+      if (res.formConfigurationId) {
+        this._showFormById(res.formConfigurationId, { triggerType: "automatic" });
+      }
+    });
+    flush().catch(() => {
+    });
+  }
+  // ============================================================================
+  // Preferences
+  // ============================================================================
+  setLocale(locale) {
+    this._locale = locale;
+    setPreferences({ locale }).catch(() => {
+    });
+  }
+  setCountry(country) {
+    this._country = country;
+    setPreferences({ country }).catch(() => {
+    });
+  }
+  setTheme(theme) {
+    this._theme = theme;
+  }
+  // ============================================================================
+  // Event tracking
+  // ============================================================================
+  async trackEvent(eventName) {
+    var _a;
+    if (!this._initialized) return;
+    if (this._isFullScreen) return;
+    const deviceInfo = await this._buildDeviceInfo();
+    const req = {
+      eventName,
+      $deviceInfo: deviceInfo,
+      $feedbackTransactions: (_a = this._feedbackTransactions) != null ? _a : void 0
+    };
+    enqueue("trackEvent", async () => {
+      var _a2;
+      const res = await this._post(ENDPOINTS.TRACK_EVENT, req);
+      if (res.$feedbackTransactions) {
+        this._feedbackTransactions = res.$feedbackTransactions;
+        const key = (_a2 = this._userName) != null ? _a2 : "anonymous";
+        await setFeedbackTransactions(key, res.$feedbackTransactions);
+      }
+      this._handleResponseMeta(res);
+      if (res.formConfigurationId) {
+        this._showFormById(res.formConfigurationId, { triggerType: "automatic" });
+      }
+    });
+    flush().catch(() => {
+    });
+  }
+  /**
+   * Best-effort server call for form lifecycle events (form:show, form:started, etc.).
+   * Not enqueued — matches web SDK behaviour where form events are fire-and-forget.
+   */
+  async _trackFormEvent(eventName, feedbackConfigurationId) {
+    var _a, _b;
+    if (!this._initialized) return;
+    const deviceInfo = await this._buildDeviceInfo();
+    const req = {
+      eventName,
+      feedbackConfigurationId,
+      $deviceInfo: deviceInfo,
+      $feedbackTransactions: (_a = this._feedbackTransactions) != null ? _a : void 0
+    };
+    try {
+      const res = await this._post(ENDPOINTS.TRACK_EVENT, req);
+      if (res.$feedbackTransactions) {
+        this._feedbackTransactions = res.$feedbackTransactions;
+        const key = (_b = this._userName) != null ? _b : "anonymous";
+        await setFeedbackTransactions(key, res.$feedbackTransactions);
+      }
+      this._handleResponseMeta(res);
+      if (res.formConfigurationId) {
+        this._showFormById(res.formConfigurationId, { triggerType: "automatic" });
+      }
+    } catch (e) {
+    }
+  }
+  async trackScreen(screenName) {
+    var _a;
+    if (!this._initialized) return;
+    if (this._isFullScreen) return;
+    this._currentScreen = screenName;
+    const deviceInfo = await this._buildDeviceInfo(screenName);
+    const req = {
+      $deviceInfo: deviceInfo,
+      $feedbackTransactions: (_a = this._feedbackTransactions) != null ? _a : void 0
+    };
+    enqueue("trackScreen", async () => {
+      var _a2;
+      const res = await this._post(ENDPOINTS.TRACK_SCREEN, req);
+      if (res.$feedbackTransactions) {
+        this._feedbackTransactions = res.$feedbackTransactions;
+        const key = (_a2 = this._userName) != null ? _a2 : "anonymous";
+        await setFeedbackTransactions(key, res.$feedbackTransactions);
+      }
+      this._handleResponseMeta(res);
+      if (res.formConfigurationId) {
+        this._showFormById(res.formConfigurationId, { triggerType: "automatic" });
+      }
+      if (res.nextFeedbackId) {
+        const delay = typeof res.onPageDelay === "number" ? res.onPageDelay : 0;
+        setTimeout(() => {
+          this._showFormById(res.nextFeedbackId, { triggerType: "automatic", reset: "always" });
+        }, delay * 1e3);
+      }
+    });
+    flush().catch(() => {
+    });
+  }
+  // ============================================================================
+  // Form display
+  // ============================================================================
+  async showForm(formId, options) {
+    if (!this._initialized) return;
+    await this._showFormInternal(formId, __spreadProps(__spreadValues({}, options), { triggerType: "manual" }));
+  }
+  async _showFormInternal(formId, options) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const resetMode = (_a = options == null ? void 0 : options.reset) != null ? _a : "always";
+    const triggerType = (_b = options == null ? void 0 : options.triggerType) != null ? _b : "manual";
+    const deviceInfo = await this._buildDeviceInfo();
+    const req = {
+      formSlugOrId: formId,
+      triggerType,
+      language: (_c = this._locale) != null ? _c : void 0,
+      $deviceInfo: deviceInfo,
+      $feedbackTransactions: (_d = this._feedbackTransactions) != null ? _d : void 0
+    };
+    try {
+      const res = await this._post(ENDPOINTS.SHOW_FORM, req);
+      if (res.$feedbackTransactions) {
+        this._feedbackTransactions = res.$feedbackTransactions;
+        const key = (_e = this._userName) != null ? _e : "anonymous";
+        await setFeedbackTransactions(key, res.$feedbackTransactions);
+      }
+      this._handleResponseMeta(res);
+      const prefillResponses = this.getPendingResponses();
+      const payload = {
+        formId,
+        formConfig: res,
+        resetMode,
+        triggerType,
+        prefillResponses,
+        locale: (_f = this._locale) != null ? _f : void 0,
+        theme: this._theme
+      };
+      if (this._onBeforeShowForm) {
+        const allow = await Promise.resolve(this._onBeforeShowForm(payload));
+        if (!allow) {
+          this.clearPendingResponses();
+          return;
+        }
+      }
+      _internalEmitter.emit("showForm", {
+        formId,
+        formConfig: res,
+        resetMode,
+        triggerType,
+        prefillResponses: Object.keys(prefillResponses).length > 0 ? prefillResponses : void 0,
+        locale: (_g = this._locale) != null ? _g : void 0,
+        theme: this._theme
+      });
+      this._isFormVisible = true;
+    } catch (err) {
+      this._logger.warn("showForm API error:", err);
+    }
+  }
+  /** Used internally when server returns a formConfigurationId auto-trigger */
+  _showFormById(formConfigurationId, options) {
+    this._showFormInternal(formConfigurationId, options).catch(() => {
+    });
+  }
+  async dismissForm(formConfigurationId) {
+    var _a, _b;
+    if (!this._initialized) return;
+    _internalEmitter.emit("dismissForm", { formConfigurationId });
+    this._isFormVisible = false;
+    this._trackFormEvent("form:dismissed", formConfigurationId).catch(() => {
+    });
+    const deviceInfo = await this._buildDeviceInfo();
+    const req = {
+      formConfigurationId,
+      $deviceInfo: deviceInfo,
+      $feedbackTransactions: (_a = this._feedbackTransactions) != null ? _a : void 0
+    };
+    try {
+      const res = await this._post(ENDPOINTS.DISMISS_FORM, req);
+      if (res.$feedbackTransactions) {
+        this._feedbackTransactions = res.$feedbackTransactions;
+        const key = (_b = this._userName) != null ? _b : "anonymous";
+        await setFeedbackTransactions(key, res.$feedbackTransactions);
+      }
+      this._handleResponseMeta(res);
+    } catch (e) {
+    }
+    this.emitEvent("form:dismissed", { formId: formConfigurationId != null ? formConfigurationId : "" });
+  }
+  addToResponse(questionId, value) {
+    this._pendingResponses[questionId] = value;
+  }
+  getPendingResponses() {
+    return __spreadValues({}, this._pendingResponses);
+  }
+  clearPendingResponses() {
+    this._pendingResponses = {};
+  }
+  // ============================================================================
+  // Submit form (called by EncatchWebView after form:submit)
+  // ============================================================================
+  async submitForm(params) {
+    var _a, _b;
+    if (!this._initialized) return;
+    const deviceInfo = await this._buildDeviceInfo();
+    const req = __spreadProps(__spreadValues({}, params), {
+      $deviceInfo: deviceInfo,
+      $feedbackTransactions: (_a = this._feedbackTransactions) != null ? _a : void 0
+    });
+    try {
+      const res = await this._post(ENDPOINTS.SUBMIT_FORM, req);
+      if (res.$feedbackTransactions) {
+        this._feedbackTransactions = res.$feedbackTransactions;
+        const key = (_b = this._userName) != null ? _b : "anonymous";
+        await setFeedbackTransactions(key, res.$feedbackTransactions);
+      }
+      this._handleResponseMeta(res);
+    } catch (err) {
+      this._logger.warn("submitForm API error:", err);
+    }
+  }
+  // ============================================================================
+  // Refine text (called by EncatchWebView after form:refineTextRequest)
+  // ============================================================================
+  async refineText(params) {
+    var _a;
+    if (!this._initialized) throw new Error("[Encatch] SDK not initialized");
+    const deviceInfo = await this._buildDeviceInfo();
+    const req = __spreadProps(__spreadValues({}, params), {
+      $deviceInfo: deviceInfo,
+      $feedbackTransactions: (_a = this._feedbackTransactions) != null ? _a : void 0
+    });
+    return this._post(ENDPOINTS.REFINE_TEXT, req);
+  }
+  // ============================================================================
+  // Session management
+  // ============================================================================
+  async startSession(options) {
+    if (!this._initialized) return;
+    if (this._isFullScreen) {
+      this._logger.debug("Skipping session tracking - fullscreen mode");
+      return;
+    }
+    this._sessionId = await getOrCreateSessionId();
+    this._startPingInterval();
+    if (!(options == null ? void 0 : options.skipImmediatePing)) {
+      this._doPing().catch(() => {
+      });
+    }
+    if (!(options == null ? void 0 : options.skipImmediateTrackScreen) && this._currentScreen) {
+      this.trackScreen(this._currentScreen).catch(() => {
+      });
+    }
+  }
+  async resetUser() {
+    if (this._userName) {
+      await Promise.all([
+        clearUserId(this._userName),
+        clearFeedbackTransactions(this._userName)
+      ]);
+    }
+    await clearFeedbackTransactions("anonymous");
+    await clearUserName();
+    await clearSession();
+    await clearPreferences();
+    this._userName = null;
+    this._userId = null;
+    this._userSignature = null;
+    this._feedbackTransactions = null;
+    this._locale = null;
+    this._country = null;
+    this._sessionId = await getOrCreateSessionId();
+    this._stopPingInterval();
+    _internalEmitter.emit("userIdentified", { userName: null, userId: null });
+  }
+  // ============================================================================
+  // Ping mechanism (mirrors web SDK)
+  // ============================================================================
+  _startPingInterval() {
+    this._stopPingInterval();
+    this._isPingActive = true;
+    this._pingIntervalId = setInterval(() => {
+      if (this._isFormVisible) return;
+      this._doPing().catch(() => {
+      });
+    }, this._pingIntervalMs);
+  }
+  _stopPingInterval() {
+    this._isPingActive = false;
+    if (this._pingIntervalId) {
+      clearInterval(this._pingIntervalId);
+      this._pingIntervalId = null;
+    }
+    if (this._pingTimeoutId) {
+      clearTimeout(this._pingTimeoutId);
+      this._pingTimeoutId = null;
+    }
+  }
+  _scheduleNextPing(delayMs) {
+    this._stopPingInterval();
+    this._pingTimeoutId = setTimeout(async () => {
+      if (!this._isFormVisible) {
+        try {
+          await this._doPing();
+        } catch (e) {
+        }
+      }
+      this._startPingInterval();
+    }, delayMs);
+  }
+  async _doPing() {
+    var _a, _b, _c;
+    const deviceInfo = await this._buildDeviceInfo((_a = this._currentScreen) != null ? _a : void 0);
+    const req = {
+      $deviceInfo: deviceInfo,
+      $feedbackTransactions: (_b = this._feedbackTransactions) != null ? _b : void 0
+    };
+    const res = await this._post(ENDPOINTS.PING, req);
+    if (res.$feedbackTransactions) {
+      this._feedbackTransactions = res.$feedbackTransactions;
+      const key = (_c = this._userName) != null ? _c : "anonymous";
+      await setFeedbackTransactions(key, res.$feedbackTransactions);
+    }
+    this._handleResponseMeta(res);
+    if (res.formConfigurationId) {
+      this._showFormById(res.formConfigurationId, { triggerType: "automatic" });
+    }
+  }
+  // ============================================================================
+  // Form visibility state (used by EncatchWebView)
+  // ============================================================================
+  setFormVisible(visible) {
+    this._isFormVisible = visible;
+  }
+  // ============================================================================
+  // API response meta handler
+  // ============================================================================
+  _handleResponseMeta(res) {
+    if (typeof res.pingAgainIn === "number" && res.pingAgainIn > 0 && this._isPingActive) {
+      this._scheduleNextPing(res.pingAgainIn * 1e3);
+    }
+  }
+  // ============================================================================
+  // SDK events (external callbacks)
+  // ============================================================================
+  on(callback) {
+    this._eventCallbacks.push(callback);
+    return () => this.off(callback);
+  }
+  off(callback) {
+    const idx = this._eventCallbacks.indexOf(callback);
+    if (idx !== -1) this._eventCallbacks.splice(idx, 1);
+  }
+  emitEvent(eventType, payload) {
+    const full = __spreadProps(__spreadValues({}, payload), { timestamp: Date.now() });
+    for (const cb of this._eventCallbacks) {
+      try {
+        cb(eventType, full);
+      } catch (e) {
+      }
+    }
+  }
+  // ============================================================================
+  // Device info builder
+  // ============================================================================
+  async _buildDeviceInfo(screenName) {
+    var _a, _b, _c, _d;
+    const locale = await getDeviceLocale();
+    const osVersion = getOsVersion();
+    const platform = getPlatform();
+    const timezone = getTimezone();
+    const deviceType = getDeviceTypeEnv();
+    const deviceSize = deviceType === "web" ? getDeviceSize() : void 0;
+    return {
+      $deviceOs: platform,
+      $deviceVersion: osVersion,
+      $deviceOsVersion: osVersion,
+      $deviceType: deviceType,
+      $deviceSize: deviceSize,
+      $sdkVersion: SDK_VERSION,
+      $appVersion: this._appVersion,
+      $app: (_a = this._appPackageName) != null ? _a : void 0,
+      $deviceLanguage: locale,
+      $userLanguage: (_b = this._locale) != null ? _b : locale,
+      $countryCode: (_c = this._country) != null ? _c : void 0,
+      $preferredTheme: this._theme,
+      $timezone: timezone != null ? timezone : void 0,
+      $urlOrScreenName: (_d = screenName != null ? screenName : this._currentScreen) != null ? _d : void 0
+    };
+  }
+  // ============================================================================
+  // HTTP client (plain fetch, no external dependency)
+  // ============================================================================
+  async _post(endpoint, body, opts) {
+    if (!this._apiKey) throw new Error("[Encatch] SDK not initialized");
+    const url = `${this._apiBaseUrl}/${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Api-Key": this._apiKey
+    };
+    if (this._sessionId) headers["X-Session-Id"] = this._sessionId;
+    if (this._userName) headers["X-User-Name"] = this._userName;
+    if (this._userId) headers["X-User-Id"] = this._userId;
+    if (this._userSignature) headers["X-User-Signature"] = this._userSignature;
+    if (this._deviceId) headers["X-Device-Id"] = this._deviceId;
+    if (opts == null ? void 0 : opts.signatureTime) headers["X-User-Signature-Time"] = opts.signatureTime;
+    if (this._appPackageName) headers["Referer"] = this._appPackageName;
+    const bodyStr = JSON.stringify(body);
+    if (this._debugMode) {
+      const headersForLog = __spreadValues({}, headers);
+      if (headersForLog["X-Api-Key"]) headersForLog["X-Api-Key"] = "***";
+      this._logger.debug(`POST ${endpoint} -> ${url}`);
+      this._logger.debug("Request headers:\n" + JSON.stringify(headersForLog, null, 2));
+      this._logger.debug("Request body:\n" + JSON.stringify(body, null, 2));
+    }
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: bodyStr
+    });
+    const responseText = await res.text().catch(() => "");
+    if (this._debugMode) {
+      const resHeaders = {};
+      res.headers.forEach((v, k) => {
+        resHeaders[k] = v;
+      });
+      this._logger.debug(`POST ${endpoint} <- ${res.status}`);
+      this._logger.debug("Response headers:\n" + JSON.stringify(resHeaders, null, 2));
+      try {
+        const resBody = JSON.parse(responseText);
+        this._logger.debug("Response body:\n" + JSON.stringify(resBody, null, 2));
+      } catch (e) {
+        this._logger.debug("Response body:\n" + responseText);
+      }
+    }
+    try {
+      const parsedForCheck = JSON.parse(responseText);
+      if (parsedForCheck && typeof parsedForCheck === "object" && parsedForCheck.user_pending_retry_exhausted === true) {
+        console.log("USER identification timeout for encatch SDK");
+        this._stopPingInterval();
+        this.resetUser().catch(() => {
+        });
+      }
+    } catch (e) {
+    }
+    if (!res.ok) {
+      const errMsg = `[Encatch API] ${endpoint} failed with status ${res.status}: ${responseText}`;
+      this._logger.warn(errMsg);
+      throw new Error(errMsg);
+    }
+    return JSON.parse(responseText);
+  }
+  // ============================================================================
+  // Getters (read-only, used by EncatchWebView / EncatchProvider)
+  // ============================================================================
+  get isInitialized() {
+    return this._initialized;
+  }
+  get apiKey() {
+    return this._apiKey;
+  }
+  get baseUrl() {
+    return this._apiBaseUrl;
+  }
+  get webHost() {
+    return this._webHost;
+  }
+  get isFullScreen() {
+    return this._isFullScreen;
+  }
+  get theme() {
+    return this._theme;
+  }
+  get locale() {
+    return this._locale;
+  }
+  get deviceId() {
+    return this._deviceId;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  get userName() {
+    return this._userName;
+  }
+  get userId() {
+    return this._userId;
+  }
+  get debugMode() {
+    return this._debugMode;
+  }
+  // ============================================================================
+  // Teardown
+  // ============================================================================
+  stop() {
+    this._stopPingInterval();
+    stopAppStateListener();
+  }
+};
+var Encatch = new EncatchSDK();
+
+// src/EncatchProvider.tsx
+var import_react = require("react");
+var useNavigationState = null;
+var useSegments = null;
+var usePathname = null;
+var useGlobalSearchParams = null;
+try {
+  const reactNavigation = require("@react-navigation/native");
+  useNavigationState = reactNavigation.useNavigationState;
+} catch (e) {
+}
+try {
+  const expoRouter = require("expo-router");
+  useSegments = expoRouter.useSegments;
+  usePathname = expoRouter.usePathname;
+  useGlobalSearchParams = expoRouter.useGlobalSearchParams;
+} catch (e) {
+}
+function isRouteSkipped(path, skippedRoutes) {
+  return skippedRoutes.some((skip) => skip.toLowerCase() === path.toLowerCase());
+}
+var ExpoRouterTracker = ({ skippedRoutes }) => {
+  var _a, _b, _c;
+  const segments = (_a = useSegments == null ? void 0 : useSegments()) != null ? _a : [];
+  const pathname = (_b = usePathname == null ? void 0 : usePathname()) != null ? _b : "";
+  const params = (_c = useGlobalSearchParams == null ? void 0 : useGlobalSearchParams()) != null ? _c : {};
+  (0, import_react.useEffect)(() => {
+    if (!pathname) return;
+    const pathParamKeys = segments.filter((s) => s.startsWith("[") && s.endsWith("]")).map((s) => s.slice(1, -1));
+    const queryParams = {};
+    for (const key of Object.keys(params)) {
+      if (!pathParamKeys.includes(key) && key !== "#") {
+        queryParams[key] = params[key];
+      }
+    }
+    let fullPath = pathname;
+    if (params["#"]) fullPath += `#${params["#"]}`;
+    if (isRouteSkipped(fullPath, skippedRoutes)) return;
+    Encatch.trackScreen(fullPath);
+  }, [pathname, segments, params]);
+  return null;
+};
+var ReactNavigationTracker = ({ skippedRoutes }) => {
+  const navigationState = useNavigationState == null ? void 0 : useNavigationState((state) => state);
+  (0, import_react.useEffect)(() => {
+    if (!navigationState) return;
+    const getActiveRoute = (state) => {
+      var _a;
+      if (!(state == null ? void 0 : state.routes)) return { path: "/", params: {} };
+      const route = state.routes[(_a = state.index) != null ? _a : state.routes.length - 1];
+      if (route.state) return getActiveRoute(route.state);
+      const buildPath = (s, path2 = "", allParams = {}) => {
+        var _a2, _b;
+        if (!(s == null ? void 0 : s.routes)) return { path: path2, params: allParams };
+        const r = s.routes[(_a2 = s.index) != null ? _a2 : s.routes.length - 1];
+        const merged = __spreadValues(__spreadValues({}, allParams), (_b = r.params) != null ? _b : {});
+        if (r.state) return buildPath(r.state, `${path2}/${r.name}`, merged);
+        return { path: `${path2}/${r.name}`, params: merged };
+      };
+      return buildPath(state);
+    };
+    const { path, params } = getActiveRoute(navigationState);
+    if (!path || isRouteSkipped(path, skippedRoutes)) return;
+    Encatch.trackScreen(path);
+  }, [navigationState]);
+  return null;
+};
+var EncatchContext = (0, import_react.createContext)(null);
+var EncatchProvider = ({
+  children,
+  apiKey,
+  config,
+  navigationType = null,
+  skippedRoutes = []
+}) => {
+  const [isInitialized, setIsInitialized] = (0, import_react.useState)(false);
+  const [isIdentified, setIsIdentified] = (0, import_react.useState)(false);
+  const [userName, setUserName2] = (0, import_react.useState)(null);
+  const initCalled = (0, import_react.useRef)(false);
+  (0, import_react.useEffect)(() => {
+    if (initCalled.current) return;
+    initCalled.current = true;
+    Encatch.init(apiKey, config).then(async () => {
+      setIsInitialized(true);
+      setIsIdentified(!!Encatch.userName && !!Encatch.userId);
+      setUserName2(Encatch.userName);
+      await Encatch.startSession();
+    });
+    return () => {
+      Encatch.stop();
+    };
+  }, []);
+  (0, import_react.useEffect)(() => {
+    const onUserIdentified = ({ userName: name, userId }) => {
+      setIsIdentified(!!name && !!userId);
+      setUserName2(name);
+    };
+    _internalEmitter.on("userIdentified", onUserIdentified);
+    return () => {
+      _internalEmitter.off("userIdentified", onUserIdentified);
+    };
+  }, []);
+  const identifyUser = (0, import_react.useCallback)(
+    (userName2, traits, opts) => {
+      Encatch.identifyUser(userName2, traits, opts).catch(() => {
+      });
+    },
+    []
+  );
+  const setLocale = (0, import_react.useCallback)((locale) => Encatch.setLocale(locale), []);
+  const setCountry = (0, import_react.useCallback)((country) => Encatch.setCountry(country), []);
+  const setTheme = (0, import_react.useCallback)((theme) => Encatch.setTheme(theme), []);
+  const trackEvent = (0, import_react.useCallback)(
+    (eventName) => {
+      Encatch.trackEvent(eventName).catch(() => {
+      });
+    },
+    []
+  );
+  const trackScreen = (0, import_react.useCallback)(
+    (screenName) => {
+      Encatch.trackScreen(screenName).catch(() => {
+      });
+    },
+    []
+  );
+  const showForm = (0, import_react.useCallback)(
+    (formId, opts) => {
+      Encatch.showForm(formId, opts).catch(() => {
+      });
+    },
+    []
+  );
+  const dismissForm = (0, import_react.useCallback)(
+    (formConfigurationId) => {
+      Encatch.dismissForm(formConfigurationId).catch(() => {
+      });
+    },
+    []
+  );
+  const addToResponse = (0, import_react.useCallback)(
+    (questionId, value) => Encatch.addToResponse(questionId, value),
+    []
+  );
+  const resetUser = (0, import_react.useCallback)(() => {
+    Encatch.resetUser().catch(() => {
+    });
+  }, []);
+  const on = (0, import_react.useCallback)((callback) => Encatch.on(callback), []);
+  const off = (0, import_react.useCallback)((callback) => Encatch.off(callback), []);
+  const submitForm = (0, import_react.useCallback)(
+    (params) => {
+      Encatch.submitForm(params).catch(() => {
+      });
+    },
+    []
+  );
+  const emitEvent = (0, import_react.useCallback)(
+    (eventType, payload) => {
+      Encatch.emitEvent(eventType, payload);
+    },
+    []
+  );
+  const refineText = (0, import_react.useCallback)((params) => {
+    return Encatch.refineText(params);
+  }, []);
+  const contextValue = {
+    isInitialized,
+    isIdentified,
+    userName,
+    identifyUser,
+    setLocale,
+    setCountry,
+    setTheme,
+    trackEvent,
+    trackScreen,
+    showForm,
+    dismissForm,
+    addToResponse,
+    resetUser,
+    on,
+    off,
+    submitForm,
+    emitEvent,
+    refineText
+  };
+  return <EncatchContext.Provider value={contextValue}>
+      {navigationType === "expo-router" && useSegments && <ExpoRouterTracker skippedRoutes={skippedRoutes} />}
+      {navigationType === "react-navigation" && useNavigationState && <ReactNavigationTracker skippedRoutes={skippedRoutes} />}
+      {children}
+    </EncatchContext.Provider>;
+};
+function useEncatch() {
+  const context = (0, import_react.useContext)(EncatchContext);
+  if (!context) {
+    throw new Error("[Encatch] useEncatch must be used within an <EncatchProvider>");
+  }
+  return context;
+}
+
+// src/EncatchWebView.tsx
+var import_react2 = require("react");
+var import_react_native3 = require("react-native");
+var import_react_native_webview = require("react-native-webview");
+function hexWithAlpha(hex, alphaHex = "4D") {
+  let h = hex.replace("#", "");
+  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
+  if (h.length === 6) return `#${h}${alphaHex}`;
+  if (h.length === 8) return `#${h}`;
+  return `#000000${alphaHex}`;
+}
+function getPositionLayout(position) {
+  let justifyContent = "center";
+  let alignItems = "center";
+  if (position.startsWith("top")) justifyContent = "flex-start";
+  else if (position.startsWith("bottom")) justifyContent = "flex-end";
+  if (position.endsWith("left")) alignItems = "flex-start";
+  else if (position.endsWith("right")) alignItems = "flex-end";
+  return { justifyContent, alignItems };
+}
+function getBorderRadii(position) {
+  const hasTop = position.includes("top");
+  const hasBottom = position.includes("bottom");
+  return {
+    borderTopLeftRadius: hasTop ? 0 : 20,
+    borderTopRightRadius: hasTop ? 0 : 20,
+    borderBottomLeftRadius: hasBottom ? 0 : 20,
+    borderBottomRightRadius: hasBottom ? 0 : 20
+  };
+}
+function getAnimationConfig(position) {
+  if (position.startsWith("top")) {
+    return { type: "slide", tx: 0, ty: -100 };
+  }
+  if (position.startsWith("bottom")) {
+    return { type: "slide", tx: 0, ty: 100 };
+  }
+  if (position.endsWith("left")) {
+    return { type: "slide", tx: -100, ty: 0 };
+  }
+  if (position.endsWith("right")) {
+    return { type: "slide", tx: 100, ty: 0 };
+  }
+  return { type: "scale", tx: 0, ty: 0 };
+}
+function calcMaxWidth(screenWidth) {
+  if (screenWidth < 600) return screenWidth;
+  if (screenWidth < 1200) return screenWidth * 0.5;
+  return screenWidth * 0.4;
+}
+function getPopoverColor(themeJson, fallback) {
+  if (!themeJson || themeJson === "{}") return fallback;
+  try {
+    const vars = JSON.parse(themeJson);
+    const value = vars["--popover"];
+    return typeof value === "string" && value.length > 0 ? value : fallback;
+  } catch (e) {
+    return fallback;
+  }
+}
+function resolveActiveMode(shareableMode) {
+  if (shareableMode === "light") return "light";
+  if (shareableMode === "dark") return "dark";
+  return import_react_native3.Appearance.getColorScheme() === "dark" ? "dark" : "light";
+}
+var EncatchWebView = () => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const webViewRef = (0, import_react2.useRef)(null);
+  const [visible, setVisible] = (0, import_react2.useState)(false);
+  const [webViewReady, setWebViewReady] = (0, import_react2.useState)(false);
+  const [showCloseButton, setShowCloseButton] = (0, import_react2.useState)(true);
+  const [isClosing, setIsClosing] = (0, import_react2.useState)(false);
+  const [formPayload, setFormPayload] = (0, import_react2.useState)(null);
+  const [screenWidth, setScreenWidth] = (0, import_react2.useState)(import_react_native3.Dimensions.get("window").width);
+  const [screenHeight, setScreenHeight] = (0, import_react2.useState)(import_react_native3.Dimensions.get("window").height);
+  const animatedHeight = (0, import_react2.useRef)(new import_react_native3.Animated.Value(300)).current;
+  const heightTimeoutRef = (0, import_react2.useRef)(null);
+  const fadeAnim = (0, import_react2.useRef)(new import_react_native3.Animated.Value(0)).current;
+  const scaleAnim = (0, import_react2.useRef)(new import_react_native3.Animated.Value(0.8)).current;
+  const translateXAnim = (0, import_react2.useRef)(new import_react_native3.Animated.Value(0)).current;
+  const translateYAnim = (0, import_react2.useRef)(new import_react_native3.Animated.Value(0)).current;
+  const formAnsweredTracked = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  const pendingDismissResolverRef = (0, import_react2.useRef)(null);
+  const position = (_c = (_b = (_a = formPayload == null ? void 0 : formPayload.formConfig) == null ? void 0 : _a.appearanceProperties) == null ? void 0 : _b.selectedPosition) != null ? _c : "center";
+  const overlayColor = (_h = (_g = (_f = (_e = (_d = formPayload == null ? void 0 : formPayload.formConfig) == null ? void 0 : _d.appearanceProperties) == null ? void 0 : _e.themes) == null ? void 0 : _f.dark) == null ? void 0 : _g.overlayColor) != null ? _h : "#000000";
+  const popupBgColor = (0, import_react2.useMemo)(() => {
+    var _a2, _b2, _c2, _d2;
+    const appearanceProperties = (_a2 = formPayload == null ? void 0 : formPayload.formConfig) == null ? void 0 : _a2.appearanceProperties;
+    const shareableMode = (_b2 = appearanceProperties == null ? void 0 : appearanceProperties.featureSettings) == null ? void 0 : _b2.shareableMode;
+    const activeMode = resolveActiveMode(shareableMode);
+    const themeJson = (_d2 = (_c2 = appearanceProperties == null ? void 0 : appearanceProperties.themes) == null ? void 0 : _c2[activeMode]) == null ? void 0 : _d2.theme;
+    const fallback = activeMode === "dark" ? "#1a1a1a" : "#ffffff";
+    return getPopoverColor(themeJson, fallback);
+  }, [formPayload]);
+  (0, import_react2.useEffect)(() => {
+    const sub = import_react_native3.Dimensions.addEventListener("change", ({ window }) => {
+      setScreenWidth(window.width);
+      setScreenHeight(window.height);
+    });
+    return () => sub.remove();
+  }, []);
+  const maxWidth = (0, import_react2.useMemo)(() => calcMaxWidth(screenWidth), [screenWidth]);
+  const runEntranceAnimation = (0, import_react2.useCallback)(
+    (pos) => {
+      const cfg = getAnimationConfig(pos);
+      translateXAnim.setValue(cfg.tx);
+      translateYAnim.setValue(cfg.ty);
+      scaleAnim.setValue(cfg.type === "scale" ? 0.8 : 1);
+      fadeAnim.setValue(0);
+      const anims = [
+        import_react_native3.Animated.timing(fadeAnim, { toValue: 1, duration: 300, useNativeDriver: false })
+      ];
+      if (cfg.type === "slide") {
+        anims.push(
+          import_react_native3.Animated.spring(translateXAnim, { toValue: 0, tension: 50, friction: 8, useNativeDriver: false }),
+          import_react_native3.Animated.spring(translateYAnim, { toValue: 0, tension: 50, friction: 8, useNativeDriver: false })
+        );
+      } else {
+        anims.push(
+          import_react_native3.Animated.spring(scaleAnim, { toValue: 1, tension: 50, friction: 8, useNativeDriver: false })
+        );
+      }
+      import_react_native3.Animated.parallel(anims).start();
+    },
+    [fadeAnim, scaleAnim, translateXAnim, translateYAnim]
+  );
+  const runExitAnimation = (0, import_react2.useCallback)(
+    (onDone, pos) => {
+      const cfg = getAnimationConfig(pos);
+      const anims = [
+        import_react_native3.Animated.timing(fadeAnim, { toValue: 0, duration: 250, useNativeDriver: false })
+      ];
+      if (cfg.type === "slide") {
+        anims.push(
+          import_react_native3.Animated.spring(translateXAnim, { toValue: cfg.tx, tension: 50, friction: 8, useNativeDriver: false }),
+          import_react_native3.Animated.spring(translateYAnim, { toValue: cfg.ty, tension: 50, friction: 8, useNativeDriver: false })
+        );
+      } else {
+        anims.push(
+          import_react_native3.Animated.spring(scaleAnim, { toValue: 0.8, tension: 50, friction: 8, useNativeDriver: false })
+        );
+      }
+      import_react_native3.Animated.parallel(anims).start(() => onDone());
+    },
+    [fadeAnim, scaleAnim, translateXAnim, translateYAnim]
+  );
+  (0, import_react2.useEffect)(() => {
+    const onShowForm = (payload) => {
+      setFormPayload(payload);
+      setShowCloseButton(true);
+      setIsClosing(false);
+      setWebViewReady(false);
+      fadeAnim.setValue(0);
+      setVisible(true);
+      animatedHeight.setValue(300);
+      Encatch.setFormVisible(true);
+    };
+    const onDismissForm = () => {
+      var _a2, _b2, _c2;
+      if (!visible) return;
+      const pos = (_c2 = (_b2 = (_a2 = formPayload == null ? void 0 : formPayload.formConfig) == null ? void 0 : _a2.appearanceProperties) == null ? void 0 : _b2.selectedPosition) != null ? _c2 : "center";
+      runExitAnimation(() => {
+        setVisible(false);
+        setWebViewReady(false);
+        setFormPayload(null);
+        Encatch.setFormVisible(false);
+      }, pos);
+    };
+    _internalEmitter.on("showForm", onShowForm);
+    _internalEmitter.on("dismissForm", onDismissForm);
+    return () => {
+      _internalEmitter.off("showForm", onShowForm);
+      _internalEmitter.off("dismissForm", onDismissForm);
+    };
+  }, [visible, runExitAnimation, animatedHeight, formPayload]);
+  const handleClose = (0, import_react2.useCallback)(() => {
+    if (isClosing) return;
+    setIsClosing(true);
+    runExitAnimation(() => {
+      setVisible(false);
+      setWebViewReady(false);
+      setFormPayload(null);
+      Encatch.setFormVisible(false);
+    }, position);
+  }, [isClosing, runExitAnimation, position]);
+  const updateHeight = (0, import_react2.useCallback)(
+    (newHeight) => {
+      if (heightTimeoutRef.current) clearTimeout(heightTimeoutRef.current);
+      heightTimeoutRef.current = setTimeout(() => {
+        const capped = Math.min(newHeight, screenHeight * 0.8);
+        import_react_native3.Animated.timing(animatedHeight, {
+          toValue: capped,
+          duration: 150,
+          useNativeDriver: false
+        }).start();
+      }, 10);
+    },
+    [animatedHeight, screenHeight]
+  );
+  (0, import_react2.useEffect)(() => {
+    return () => {
+      if (heightTimeoutRef.current) clearTimeout(heightTimeoutRef.current);
+    };
+  }, []);
+  const injectSDKMessage = (0, import_react2.useCallback)((msg) => {
+    if (!webViewRef.current) return;
+    const js = `
+      window.dispatchEvent(new MessageEvent('message', {
+        data: ${JSON.stringify(msg)}
+      }));
+      true;
+    `;
+    webViewRef.current.injectJavaScript(js);
+  }, []);
+  const DISMISS_READY_TIMEOUT_MS = 3e3;
+  const handleDismissWithPartialSubmit = (0, import_react2.useCallback)(() => {
+    var _a2;
+    if (isClosing) return;
+    const partialResponseEnabled = ((_a2 = formPayload == null ? void 0 : formPayload.formConfig) == null ? void 0 : _a2.partialResponseEnabled) === true;
+    if (!partialResponseEnabled) {
+      handleClose();
+      return;
+    }
+    injectSDKMessage({ type: "sdk:submitPartialBeforeDismiss", data: {} });
+    const timeout = setTimeout(() => {
+      if (pendingDismissResolverRef.current) {
+        pendingDismissResolverRef.current = null;
+        handleClose();
+      }
+    }, DISMISS_READY_TIMEOUT_MS);
+    pendingDismissResolverRef.current = () => {
+      clearTimeout(timeout);
+      pendingDismissResolverRef.current = null;
+      handleClose();
+    };
+  }, [isClosing, formPayload, injectSDKMessage, handleClose]);
+  const handleWebViewMessage = (0, import_react2.useCallback)(
+    async (event) => {
+      var _a2, _b2, _c2, _d2, _e2, _f2, _g2, _h2, _i;
+      let parsed;
+      try {
+        parsed = JSON.parse(event.nativeEvent.data);
+      } catch (e) {
+        console.warn("[EncatchWebView] Failed to parse WebView message:", event.nativeEvent.data);
+        return;
+      }
+      const { type, data } = parsed;
+      switch (type) {
+        case "form:ready": {
+          if (!formPayload) return;
+          const { formConfig, resetMode, triggerType, prefillResponses, locale, theme } = formPayload;
+          injectSDKMessage({
+            type: "sdk:formConfig",
+            data: __spreadProps(__spreadValues({}, formConfig), {
+              triggerType
+            })
+          });
+          if (resetMode === "always") {
+            injectSDKMessage({ type: "sdk:resetData" });
+          }
+          if (prefillResponses && Object.keys(prefillResponses).length > 0) {
+            injectSDKMessage({ type: "sdk:prefillResponses", data: { responses: prefillResponses } });
+          } else {
+            const pending = Encatch.getPendingResponses();
+            if (Object.keys(pending).length > 0) {
+              injectSDKMessage({ type: "sdk:prefillResponses", data: { responses: pending } });
+              Encatch.clearPendingResponses();
+            }
+          }
+          if (theme) {
+            injectSDKMessage({ type: "sdk:theme", data: { theme } });
+          }
+          if (locale) {
+            injectSDKMessage({ type: "sdk:locale", data: { locale } });
+          }
+          setWebViewReady(true);
+          runEntranceAnimation(
+            (_b2 = (_a2 = formConfig == null ? void 0 : formConfig.appearanceProperties) == null ? void 0 : _a2.selectedPosition) != null ? _b2 : "center"
+          );
+          break;
+        }
+        case "form:resize": {
+          const h = data == null ? void 0 : data.height;
+          if (typeof h === "number" && h > 0) {
+            updateHeight(h);
+          }
+          break;
+        }
+        case "form:closeButton": {
+          setShowCloseButton((data == null ? void 0 : data.show) !== false);
+          break;
+        }
+        case "form:themeData": {
+          break;
+        }
+        case "form:submit": {
+          if (!data) break;
+          const submitReq = {
+            triggerType: (_c2 = data.triggerType) != null ? _c2 : "manual",
+            formDetails: {
+              formConfigurationId: data.feedbackConfigurationId,
+              isPartialSubmit: (_d2 = data.isPartialSubmit) != null ? _d2 : false,
+              feedbackIdentifier: data.feedbackIdentifier,
+              responseLanguageCode: data.responseLanguageCode,
+              response: data.response,
+              completionTimeInSeconds: data.completionTimeInSeconds
+            },
+            $feedbackTransactions: void 0
+          };
+          Encatch.submitForm(submitReq).catch(() => {
+          });
+          Encatch.emitEvent("form:submit", { formId: parsed.formId, data });
+          break;
+        }
+        case "form:complete": {
+          Encatch.emitEvent("form:complete", { formId: parsed.formId, data });
+          Encatch._trackFormEvent("form:complete", data == null ? void 0 : data.feedbackConfigurationId).catch(() => {
+          });
+          formAnsweredTracked.current.delete((_e2 = parsed.formId) != null ? _e2 : "");
+          handleClose();
+          break;
+        }
+        case "form:close": {
+          Encatch.emitEvent("form:close", { formId: parsed.formId, data });
+          formAnsweredTracked.current.delete((_g2 = (_f2 = data == null ? void 0 : data.feedbackConfigurationId) != null ? _f2 : parsed.formId) != null ? _g2 : "");
+          handleClose();
+          break;
+        }
+        case "form:started": {
+          Encatch.emitEvent("form:started", { formId: parsed.formId, data });
+          Encatch._trackFormEvent("form:started", data == null ? void 0 : data.feedbackConfigurationId).catch(() => {
+          });
+          break;
+        }
+        case "form:answered": {
+          Encatch.emitEvent("form:answered", { formId: parsed.formId, data });
+          const answeredKey = (_i = (_h2 = data == null ? void 0 : data.feedbackConfigurationId) != null ? _h2 : parsed.formId) != null ? _i : "";
+          if (answeredKey && !formAnsweredTracked.current.has(answeredKey)) {
+            formAnsweredTracked.current.add(answeredKey);
+            Encatch._trackFormEvent("form:answered", data == null ? void 0 : data.feedbackConfigurationId).catch(() => {
+            });
+          }
+          break;
+        }
+        case "form:section:change": {
+          Encatch.emitEvent("form:section:change", { formId: parsed.formId, data });
+          break;
+        }
+        case "form:show": {
+          Encatch.emitEvent("form:show", { formId: parsed.formId, data });
+          Encatch._trackFormEvent("form:show", data == null ? void 0 : data.feedbackConfigurationId).catch(() => {
+          });
+          break;
+        }
+        case "form:refineTextRequest": {
+          if (!data) break;
+          const refineParams = {
+            questionId: data.questionId,
+            feedbackConfigurationId: data.feedbackConfigurationId,
+            userText: data.userText
+          };
+          try {
+            const res = await Encatch.refineText(refineParams);
+            injectSDKMessage({
+              type: "sdk:refineTextResponse",
+              data: __spreadValues({
+                requestId: data.requestId
+              }, res)
+            });
+          } catch (e) {
+            injectSDKMessage({
+              type: "sdk:refineTextResponse",
+              data: {
+                requestId: data.requestId,
+                error: "Refine text request failed"
+              }
+            });
+          }
+          break;
+        }
+        case "form:error": {
+          console.warn("[EncatchWebView] form:error received:", data);
+          Encatch.emitEvent("form:error", { formId: parsed.formId, data });
+          break;
+        }
+        case "form:readyToDismiss": {
+          if (pendingDismissResolverRef.current) {
+            pendingDismissResolverRef.current();
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    },
+    [formPayload, injectSDKMessage, updateHeight, handleClose, runEntranceAnimation]
+  );
+  const webViewUrl = (0, import_react2.useMemo)(() => {
+    if (!formPayload) return "";
+    const base = Encatch.webHost;
+    const formId = formPayload.formId;
+    const params = { formId };
+    if (Encatch.debugMode) params.debug = "true";
+    return `${base}/s/react-native-sdk-form?${new URLSearchParams(params).toString()}`;
+  }, [formPayload]);
+  const { justifyContent, alignItems } = (0, import_react2.useMemo)(() => getPositionLayout(position), [position]);
+  const borderRadii = (0, import_react2.useMemo)(() => getBorderRadii(position), [position]);
+  const styles = (0, import_react2.useMemo)(
+    () => import_react_native3.StyleSheet.create({
+      overlay: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: screenWidth,
+        height: screenHeight,
+        backgroundColor: hexWithAlpha(overlayColor),
+        justifyContent,
+        alignItems,
+        zIndex: 9999,
+        elevation: 9999
+      },
+      popupContainer: __spreadProps(__spreadValues({}, borderRadii), {
+        overflow: "hidden",
+        maxHeight: screenHeight * 0.8,
+        backgroundColor: popupBgColor
+      }),
+      closeButton: {
+        position: "absolute",
+        top: 8,
+        right: 8,
+        width: 30,
+        height: 30,
+        justifyContent: "center",
+        alignItems: "center",
+        zIndex: 2
+      },
+      closeText: {
+        fontSize: 14,
+        color: "#000",
+        fontWeight: "900"
+      }
+    }),
+    [screenWidth, screenHeight, overlayColor, popupBgColor, justifyContent, alignItems, borderRadii]
+  );
+  if (!formPayload) return null;
+  return <import_react_native3.Animated.View
+    style={[styles.overlay, { opacity: fadeAnim }]}
+    pointerEvents={webViewReady ? "box-none" : "none"}
+  >
+      <import_react_native3.Animated.View
+    style={[
+      styles.popupContainer,
+      {
+        height: animatedHeight,
+        width: maxWidth,
+        transform: [
+          { scaleX: scaleAnim },
+          { scaleY: scaleAnim },
+          { translateX: translateXAnim },
+          { translateY: translateYAnim }
+        ]
+      }
+    ]}
+  >
+        {showCloseButton && <import_react_native3.TouchableOpacity onPress={handleDismissWithPartialSubmit} style={styles.closeButton}>
+            <import_react_native3.Text style={styles.closeText}>✕</import_react_native3.Text>
+          </import_react_native3.TouchableOpacity>}
+
+        <import_react_native_webview.WebView
+    ref={webViewRef}
+    source={{ uri: webViewUrl }}
+    onMessage={handleWebViewMessage}
+    javaScriptEnabled
+    domStorageEnabled
+    startInLoadingState
+    mixedContentMode="compatibility"
+    scrollEnabled
+    bounces={false}
+    showsHorizontalScrollIndicator={false}
+    showsVerticalScrollIndicator={false}
+    allowsInlineMediaPlayback
+    mediaPlaybackRequiresUserAction={false}
+    style={{ flex: 1, backgroundColor: popupBgColor }}
+    containerStyle={{ flex: 1, backgroundColor: popupBgColor }}
+    onError={(e) => console.warn("[EncatchWebView] Load error:", e.nativeEvent)}
+    onHttpError={(e) => console.warn("[EncatchWebView] HTTP error:", e.nativeEvent.statusCode, e.nativeEvent.url)}
+  />
+      </import_react_native3.Animated.View>
+    </import_react_native3.Animated.View>;
+};
+
+// src/form-helpers.ts
+function toQuestionAnswer(type, value) {
+  switch (type) {
+    case "rating":
+      return { rating: typeof value === "number" ? value : parseInt(String(value), 10) };
+    case "nps":
+      return { nps: typeof value === "number" ? value : parseInt(String(value), 10) };
+    case "short_answer":
+      return { shortAnswer: String(value) };
+    case "long_text":
+      return { longText: String(value) };
+    case "single_choice":
+      return { singleChoice: String(value) };
+    case "multiple_choice":
+      return {
+        multipleChoiceMultiple: Array.isArray(value) ? value.map(String) : [String(value)]
+      };
+    default:
+      return { shortAnswer: String(value) };
+  }
+}
+function buildSubmitRequest(options, responses) {
+  var _a;
+  const questions = responses.map((r) => ({
+    questionId: r.questionId,
+    type: r.type,
+    answer: toQuestionAnswer(r.type, r.value)
+  }));
+  const formDetails = {
+    formConfigurationId: options.formConfigurationId,
+    responseLanguageCode: options.responseLanguageCode,
+    completionTimeInSeconds: options.completionTimeInSeconds,
+    isPartialSubmit: options.isPartialSubmit,
+    feedbackIdentifier: options.feedbackIdentifier,
+    response: { questions }
+  };
+  return {
+    triggerType: (_a = options.triggerType) != null ? _a : "manual",
+    formDetails
+  };
+}