@yesplz-ai/analytics-react-native 0.1.0

package/dist/index.js

@@ -0,0 +1,707 @@
+// src/analytics.ts
+import { Platform, AppState } from "react-native";
+
+// src/constants.ts
+var VERSION = "0.1.0-rn";
+var EventType = {
+  ViewItemList: "view_item_list",
+  ViewItem: "yp_product_view",
+  ViewProduct: "yp_product_view",
+  SelectItem: "yp_product_select",
+  SelectProduct: "yp_product_select",
+  AddToCart: "yp_product_cart",
+  RemoveFromCart: "yp_product_remove_from_cart",
+  BeginCheckout: "yp_begin_checkout",
+  Purchase: "yp_product_purchase",
+  FavoriteProduct: "yp_product_favorite",
+  UnfavoriteProduct: "yp_product_unfavorite",
+  AddToWishlist: "yp_product_favorite",
+  RemoveFromWishlist: "yp_product_unfavorite",
+  ViewBrand: "yp_brand_view",
+  FavoriteBrand: "yp_brand_favorite",
+  UnfavoriteBrand: "yp_brand_unfavorite"
+};
+var GaEventType = {
+  [EventType.ViewProduct]: "view_item",
+  [EventType.SelectItem]: "select_item",
+  [EventType.AddToCart]: "add_to_cart",
+  [EventType.RemoveFromCart]: "remove_from_cart",
+  [EventType.BeginCheckout]: "begin_checkout",
+  [EventType.Purchase]: "purchase",
+  [EventType.FavoriteProduct]: "add_to_wishlist",
+  [EventType.UnfavoriteProduct]: "remove_from_wishlist"
+};
+var GaEventTypeReverse = {
+  view_item: EventType.ViewProduct,
+  select_item: EventType.SelectItem,
+  add_to_cart: EventType.AddToCart,
+  remove_from_cart: EventType.RemoveFromCart,
+  begin_checkout: EventType.BeginCheckout,
+  purchase: EventType.Purchase,
+  add_to_wishlist: EventType.FavoriteProduct,
+  remove_from_wishlist: EventType.UnfavoriteProduct
+};
+var ItemListId = {
+  SEARCH_RESULTS: "search-results",
+  PRODUCT_LIST: "product-list",
+  YOU_MAY_ALSO_LIKE: "you-may-also-like",
+  COMPLETE_THE_LOOK: "complete-the-look",
+  COLLABORATIVE_FILTERING: "collaborative-filtering",
+  MORE_FROM_BRAND: "more-from-brand",
+  STYLE_WITH: "style-with",
+  SHOPPING_CART: "shopping-cart",
+  ITEM_FOR_YOU: "item-for-you",
+  BRAND_FOR_YOU: "brand-for-you"
+};
+var LIST_ID_ALIASES = {
+  Search: ItemListId.SEARCH_RESULTS,
+  "search-results": ItemListId.SEARCH_RESULTS,
+  PLP: ItemListId.PRODUCT_LIST,
+  "product-list": ItemListId.PRODUCT_LIST,
+  YMAL: ItemListId.YOU_MAY_ALSO_LIKE,
+  "you-may-also-like": ItemListId.YOU_MAY_ALSO_LIKE,
+  CTL: ItemListId.COMPLETE_THE_LOOK,
+  "complete-the-look": ItemListId.COMPLETE_THE_LOOK,
+  CF: ItemListId.COLLABORATIVE_FILTERING,
+  "collaborative-filtering": ItemListId.COLLABORATIVE_FILTERING,
+  "frequently-bought-together": ItemListId.COLLABORATIVE_FILTERING,
+  Brand: ItemListId.MORE_FROM_BRAND,
+  "more-from-brand": ItemListId.MORE_FROM_BRAND,
+  STW: ItemListId.STYLE_WITH,
+  "style-with": ItemListId.STYLE_WITH,
+  CART: ItemListId.SHOPPING_CART,
+  "shopping-cart": ItemListId.SHOPPING_CART,
+  "item-for-you": ItemListId.ITEM_FOR_YOU,
+  "brand-for-you": ItemListId.BRAND_FOR_YOU
+};
+function normalizeItemListId(input) {
+  if (!input) return input;
+  const alias = LIST_ID_ALIASES[input];
+  if (alias) return alias;
+  const canonical = Object.values(ItemListId);
+  if (canonical.includes(input)) return input;
+  return input;
+}
+var API_EVENTS = [
+  EventType.ViewProduct,
+  EventType.AddToCart,
+  EventType.RemoveFromCart,
+  EventType.BeginCheckout,
+  EventType.Purchase,
+  EventType.FavoriteProduct,
+  EventType.UnfavoriteProduct,
+  EventType.ViewBrand,
+  EventType.FavoriteBrand,
+  EventType.UnfavoriteBrand
+];
+
+// src/storage.ts
+import AsyncStorage from "@react-native-async-storage/async-storage";
+var StorageKeys = {
+  CID: "yp_cid",
+  SESSION: "yp_session",
+  USER_ID: "yp_user_id",
+  USER_PROPS: "yp_user_props",
+  ATTRIBUTION: "yp_attribution",
+  PENDING_EVENTS: "yp_pending_events"
+};
+var Storage = {
+  async getItem(key) {
+    try {
+      return await AsyncStorage.getItem(key);
+    } catch {
+      return null;
+    }
+  },
+  async setItem(key, value) {
+    try {
+      await AsyncStorage.setItem(key, value);
+    } catch {
+    }
+  },
+  async removeItem(key) {
+    try {
+      await AsyncStorage.removeItem(key);
+    } catch {
+    }
+  },
+  async getJSON(key, fallback) {
+    const raw = await Storage.getItem(key);
+    if (!raw) return fallback;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return fallback;
+    }
+  },
+  async setJSON(key, value) {
+    try {
+      await Storage.setItem(key, JSON.stringify(value));
+    } catch {
+    }
+  }
+};
+
+// src/ids.ts
+function generateId() {
+  return Date.now().toString(36) + Math.random().toString(36).substring(2);
+}
+function hashCode(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash |= 0;
+  }
+  return hash;
+}
+function numericSessionId(sessionId) {
+  if (!sessionId) return Math.floor(Date.now() / 1e3);
+  return Math.abs(hashCode(sessionId)) || Math.floor(Date.now() / 1e3);
+}
+async function loadIdentity() {
+  const [cidStored, sessionStored, userIdStored, userPropsStored] = await Promise.all([
+    Storage.getItem(StorageKeys.CID),
+    Storage.getItem(StorageKeys.SESSION),
+    Storage.getItem(StorageKeys.USER_ID),
+    Storage.getItem(StorageKeys.USER_PROPS)
+  ]);
+  let cid = cidStored;
+  if (!cid) {
+    cid = generateId();
+    await Storage.setItem(StorageKeys.CID, cid);
+  }
+  let sessionId = sessionStored;
+  if (!sessionId) {
+    sessionId = generateId();
+    await Storage.setItem(StorageKeys.SESSION, sessionId);
+  }
+  let userProperties = {};
+  if (userPropsStored) {
+    try {
+      userProperties = JSON.parse(userPropsStored);
+    } catch {
+      userProperties = {};
+    }
+  }
+  return { cid, sessionId, userId: userIdStored, userProperties };
+}
+async function saveSession(sessionId) {
+  await Storage.setItem(StorageKeys.SESSION, sessionId);
+}
+async function saveUser(userId, userProperties, cacheUserId) {
+  if (cacheUserId) {
+    await Storage.setItem(StorageKeys.USER_ID, userId);
+  }
+  await Storage.setJSON(StorageKeys.USER_PROPS, userProperties);
+}
+async function clearUser() {
+  await Storage.removeItem(StorageKeys.USER_ID);
+  await Storage.removeItem(StorageKeys.USER_PROPS);
+}
+
+// src/attribution.ts
+var EXPIRY_MS = 30 * 60 * 1e3;
+function normalizeId(rawId, idPrefix) {
+  if (!rawId) return null;
+  const idStr = String(rawId);
+  if (idPrefix && idStr.startsWith(idPrefix)) {
+    return idStr.slice(idPrefix.length);
+  }
+  const match = idStr.match(/^[a-zA-Z]+-(.+)$/);
+  return match ? match[1] : idStr;
+}
+async function loadStore() {
+  return Storage.getJSON(StorageKeys.ATTRIBUTION, {});
+}
+async function saveStore(store) {
+  await Storage.setJSON(StorageKeys.ATTRIBUTION, store);
+}
+function pruneExpired(store) {
+  const now = Date.now();
+  const next = {};
+  for (const [k, v] of Object.entries(store)) {
+    if (now - v.ts <= EXPIRY_MS) next[k] = v;
+  }
+  return next;
+}
+async function handleAttribution(eventType, props, idPrefix) {
+  const normalizedEventType = GaEventTypeReverse[eventType] || eventType;
+  if (normalizedEventType === EventType.SelectItem) {
+    const itemListId = props.item_list_id;
+    const rawId = props.id ?? props.items?.[0]?.item_id;
+    const productId = normalizeId(rawId, idPrefix);
+    if (itemListId && productId) {
+      let store = await loadStore();
+      store = pruneExpired(store);
+      store[productId] = { source: itemListId, ts: Date.now() };
+      await saveStore(store);
+    }
+    return;
+  }
+  if (normalizedEventType === EventType.ViewProduct) {
+    const rawId = props.id ?? props.items?.[0]?.item_id;
+    const productId = normalizeId(rawId, idPrefix);
+    if (!productId) return;
+    const store = await loadStore();
+    const entry = store[productId];
+    if (entry && Date.now() - entry.ts <= EXPIRY_MS) {
+      props.item_list_id = entry.source;
+      if (Array.isArray(props.items)) {
+        props.items = props.items.map((item) => ({ ...item, item_list_id: entry.source }));
+      }
+    }
+    return;
+  }
+  if (normalizedEventType === EventType.AddToCart) {
+    if (!Array.isArray(props.items)) return;
+    const store = await loadStore();
+    props.items = props.items.map((item) => {
+      const productId = normalizeId(item.item_id, idPrefix);
+      const entry = productId ? store[productId] : null;
+      if (entry && Date.now() - entry.ts <= EXPIRY_MS) {
+        return { ...item, item_list_id: entry.source };
+      }
+      return item;
+    });
+    const firstMatch = props.items.find((item) => item.item_list_id);
+    if (firstMatch?.item_list_id) {
+      props.item_list_id = firstMatch.item_list_id;
+    }
+  }
+}
+
+// src/ga.ts
+function toSnakeCase(str) {
+  return str.replace(/-/g, "_");
+}
+async function sendToGA(eventType, props, options) {
+  const gaEvent = GaEventType[eventType] || toSnakeCase(eventType);
+  const {
+    items,
+    currency,
+    value,
+    transaction_id,
+    tax,
+    shipping,
+    coupon,
+    ...rest
+  } = props;
+  const params = {
+    session_id: options.numericSessionId,
+    engagement_time_msec: 1,
+    session_engaged: "1"
+  };
+  if (currency) params.currency = currency;
+  if (value !== void 0) params.value = value;
+  if (transaction_id) params.transaction_id = transaction_id;
+  if (tax !== void 0) params.tax = tax;
+  if (shipping !== void 0) params.shipping = shipping;
+  if (coupon) params.coupon = coupon;
+  if (items) params.items = items;
+  const passthroughKeys = [
+    "item_list_id",
+    "data_provider",
+    "event_source",
+    "id",
+    "search_term",
+    "total",
+    "total_text",
+    "total_vector",
+    "page_location",
+    "page_title",
+    "page_referrer",
+    "language",
+    "test_marker",
+    "yp_platform",
+    "yp_platform_version",
+    "yp_user_agent"
+  ];
+  for (const key of passthroughKeys) {
+    if (rest[key] !== void 0) params[key] = rest[key];
+  }
+  const body = {
+    client_id: options.clientId || options.sessionId,
+    timestamp_micros: Date.now() * 1e3,
+    events: [{ name: gaEvent, params }]
+  };
+  if (options.userId) body.user_id = options.userId;
+  const sep = options.gaProxyUrl.includes("?") ? "&" : "?";
+  const url = options.debug ? `${options.gaProxyUrl}${sep}debug=1` : options.gaProxyUrl;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (options.debug) {
+      console.log(`[YesPlz Analytics] GA MP \u2192 ${gaEvent} (status ${res.status})`);
+    }
+  } catch (e) {
+    if (options.debug) {
+      console.log(`[YesPlz Analytics] GA MP error: ${e.message}`);
+    }
+  }
+}
+
+// src/beacon.ts
+var Beacon = class {
+  constructor(options) {
+    this.options = options;
+    this.queue = [];
+    this.isSending = false;
+    this.debounceTimer = null;
+  }
+  enqueue(event) {
+    this.queue.push(event);
+    this.scheduleSend();
+  }
+  enqueueAll(events) {
+    this.queue.push(...events);
+    this.scheduleSend();
+  }
+  scheduleSend() {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      void this.send();
+    }, this.options.debounceMs ?? 1e3);
+  }
+  async send(retryCount = 0) {
+    if (this.queue.length === 0) return;
+    if (!this.options.apiEndpoint) return;
+    if (this.isSending) return;
+    this.isSending = true;
+    const eventsToSend = this.queue.splice(0, this.queue.length);
+    const events = eventsToSend.map((event) => {
+      const merged = {
+        ...event,
+        ...this.options.defaultParams ?? {}
+      };
+      const rawId = event.extra_data.id;
+      if (rawId && this.options.idPrefix) {
+        merged.extra_data = {
+          ...event.extra_data,
+          id: `${this.options.idPrefix}${rawId}`
+        };
+      }
+      return merged;
+    });
+    try {
+      const headers = { "Content-Type": "application/json" };
+      if (this.options.apiToken) headers.Authorization = `Token ${this.options.apiToken}`;
+      const res = await fetch(this.options.apiEndpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(events)
+      });
+      if (res.status > 299) {
+        throw new Error(`Failed to send events (status ${res.status})`);
+      }
+      if (this.options.debug) {
+        console.log(`[YesPlz Analytics] Sync: ${events.length} events sent`);
+      }
+      await Storage.removeItem(StorageKeys.PENDING_EVENTS);
+    } catch (e) {
+      if (this.options.debug) {
+        console.log(`[YesPlz Analytics] Sync failed: ${e.message}`);
+      }
+      this.queue.unshift(...eventsToSend);
+      this.isSending = false;
+      if (retryCount < 1) {
+        setTimeout(() => void this.send(retryCount + 1), 2e3);
+      }
+      return;
+    }
+    this.isSending = false;
+    if (this.queue.length > 0) this.scheduleSend();
+  }
+  async flush() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    await this.send();
+  }
+  async savePending() {
+    if (this.queue.length === 0) return;
+    const toSave = this.queue.slice(-100);
+    await Storage.setJSON(StorageKeys.PENDING_EVENTS, toSave);
+    this.queue = [];
+  }
+  async restorePending() {
+    const pending = await Storage.getJSON(StorageKeys.PENDING_EVENTS, []);
+    if (pending.length > 0) {
+      this.queue.unshift(...pending);
+      await Storage.removeItem(StorageKeys.PENDING_EVENTS);
+      this.scheduleSend();
+    }
+  }
+};
+
+// src/analytics.ts
+var DEFAULT_DEBOUNCE_MS = 1e3;
+var DEFAULT_API_BASE_URL = "https://api.yesplz.ai";
+var DEFAULT_GA_PROXY_BASE_URL = "https://ypsh-admin.yesplz.ai/api/mp/collect";
+function buildUserAgent() {
+  const os = Platform.OS;
+  const version = Platform.Version;
+  return `YesPlzSDK-RN/${VERSION} (${os}; ${String(version)})`;
+}
+var Analytics = class {
+  constructor() {
+    this.config = {
+      debug: false,
+      debounceMs: DEFAULT_DEBOUNCE_MS,
+      cacheUserId: true,
+      idPrefix: ""
+    };
+    this.cid = null;
+    this.sessionId = null;
+    this.userId = null;
+    this.userProperties = {};
+    this.isInitialized = false;
+    this.initPromise = null;
+    this.beacon = null;
+    this.pendingTracks = [];
+    this.appStateSubscription = null;
+  }
+  init(appId, config = {}) {
+    if (this.isInitialized || this.initPromise) return this;
+    this.initPromise = this.initInternal(appId, config);
+    void this.initPromise;
+    return this;
+  }
+  ready() {
+    return this.initPromise ?? Promise.resolve();
+  }
+  async initInternal(appId, config) {
+    const normalizedAppId = String(appId).trim();
+    if (!normalizedAppId) {
+      throw new Error("[YesPlz Analytics] appId must be a non-empty string");
+    }
+    const apiBaseUrl = (config.apiBaseUrl || DEFAULT_API_BASE_URL).replace(/\/$/, "");
+    const apiEndpoint = config.apiEndpoint || `${apiBaseUrl}/api/v1/retailer/${encodeURIComponent(normalizedAppId)}/interactions/`;
+    const gaProxyBaseUrl = config.gaProxyBaseUrl || DEFAULT_GA_PROXY_BASE_URL;
+    const gaProxySep = gaProxyBaseUrl.includes("?") ? "&" : "?";
+    const gaProxyUrl = `${gaProxyBaseUrl}${gaProxySep}shop=${encodeURIComponent(normalizedAppId)}`;
+    const mergedDefaultParams = {
+      ...config.defaultParams || {}
+    };
+    if (config.testMarker) {
+      mergedDefaultParams.test_marker = config.testMarker;
+    }
+    this.config = {
+      ...this.config,
+      appId: normalizedAppId,
+      apiEndpoint,
+      apiBaseUrl,
+      apiToken: config.apiToken ?? null,
+      gaProxyBaseUrl,
+      gaProxyUrl,
+      idPrefix: config.idPrefix || "",
+      defaultParams: mergedDefaultParams,
+      testMarker: config.testMarker,
+      debug: config.debug ?? false,
+      cacheUserId: config.cacheUserId ?? true,
+      debounceMs: config.debounceMs || DEFAULT_DEBOUNCE_MS
+    };
+    const identity = await loadIdentity();
+    this.cid = identity.cid;
+    this.sessionId = identity.sessionId;
+    this.userId = identity.userId;
+    this.userProperties = identity.userProperties;
+    if (config.userId) {
+      await this.setUserInternal(config.userId, config.userProperties || {});
+    }
+    if (apiEndpoint) {
+      this.beacon = new Beacon({
+        apiEndpoint,
+        apiToken: this.config.apiToken,
+        defaultParams: this.config.defaultParams,
+        idPrefix: this.config.idPrefix,
+        debounceMs: this.config.debounceMs,
+        debug: this.config.debug
+      });
+      await this.beacon.restorePending();
+    }
+    this.appStateSubscription = AppState.addEventListener(
+      "change",
+      (state) => {
+        if (state === "background" || state === "inactive") {
+          void this.beacon?.savePending();
+        }
+      }
+    );
+    this.isInitialized = true;
+    this.log("Initialized");
+    const queued = this.pendingTracks.splice(0, this.pendingTracks.length);
+    for (const item of queued) {
+      void this.dispatchTrack(item.eventType, item.properties);
+    }
+  }
+  async setUser(userId, userProperties = {}) {
+    await this.ready();
+    if (userId === null) {
+      this.userId = null;
+      this.userProperties = {};
+      await clearUser();
+      this.log("User cleared");
+      return this;
+    }
+    await this.setUserInternal(userId, userProperties);
+    return this;
+  }
+  async setUserInternal(userId, userProperties) {
+    const id = String(userId);
+    if (id.length === 0) {
+      console.error("[YesPlz Analytics] User ID must be a non-empty value");
+      return;
+    }
+    this.userId = id;
+    this.userProperties = JSON.parse(JSON.stringify(userProperties));
+    await saveUser(this.userId, this.userProperties, this.config.cacheUserId);
+    this.log(`User set: ${id}`);
+  }
+  getUser() {
+    if (!this.userId) return null;
+    return { userId: this.userId, userProperties: this.userProperties };
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getClientId() {
+    return this.cid;
+  }
+  track(eventType, properties = {}) {
+    if (typeof eventType !== "string" || eventType.length === 0) {
+      console.error("[YesPlz Analytics] Event type must be a non-empty string");
+      return this;
+    }
+    if (!this.isInitialized) {
+      this.pendingTracks.push({
+        eventType,
+        properties: JSON.parse(JSON.stringify(properties))
+      });
+      return this;
+    }
+    void this.dispatchTrack(eventType, properties);
+    return this;
+  }
+  async dispatchTrack(eventType, properties) {
+    const props = JSON.parse(JSON.stringify(properties));
+    await handleAttribution(eventType, props, this.config.idPrefix);
+    if (eventType === EventType.Purchase && !props.transaction_id) {
+      props.transaction_id = generateId();
+    }
+    if (props.id && !Array.isArray(props.items)) {
+      props.items = [{ item_id: props.id, ...props }];
+    }
+    const metadata = this.collectMetadata();
+    Object.assign(props, metadata);
+    props.data_provider = "yesplz";
+    if (this.config.testMarker) {
+      props.test_marker = this.config.testMarker;
+    }
+    await this.sendGA(eventType, props);
+    const apiEventType = GaEventTypeReverse[eventType] || eventType;
+    if (API_EVENTS.includes(apiEventType)) {
+      this.queueApi(apiEventType, props, metadata);
+    }
+  }
+  async sendGA(eventType, props) {
+    if (!this.config.gaProxyUrl) return;
+    if (!this.cid || !this.sessionId) return;
+    const gaEventName = GaEventType[eventType] ?? eventType;
+    await sendToGA(eventType, props, {
+      gaProxyUrl: this.config.gaProxyUrl,
+      clientId: this.cid,
+      sessionId: this.sessionId,
+      numericSessionId: numericSessionId(this.sessionId),
+      userId: this.userId,
+      debug: this.config.debug
+    });
+    this.log(`Track: ${gaEventName}`, props.items?.length ? { items: props.items.length } : void 0);
+  }
+  queueApi(eventType, props, metadata) {
+    if (!this.beacon) return;
+    const items = props.items && props.items.length > 0 ? props.items : [props];
+    const fallbackUrl = `app://${this.config.appId ?? "yesplz"}/`;
+    const url = typeof props.page_location === "string" && props.page_location.length > 0 ? props.page_location : fallbackUrl;
+    const referrerUrl = typeof props.page_referrer === "string" && props.page_referrer.length > 0 ? props.page_referrer : null;
+    const events = items.map((item) => {
+      const merged = {
+        ...props,
+        ...item,
+        ...metadata
+      };
+      const itemId = item.item_id;
+      if (itemId) merged.id = itemId;
+      merged.identifier_type = eventType.startsWith("yp_brand_") ? "brand_name" : "product_id";
+      const event = {
+        event_type: eventType,
+        url,
+        referrer_url: referrerUrl,
+        user_id: this.userId,
+        session_id: this.sessionId,
+        extra_data: merged
+      };
+      if (Object.keys(this.userProperties).length > 0) {
+        event.extra_user_data = this.userProperties;
+      }
+      return event;
+    });
+    this.beacon.enqueueAll(events);
+  }
+  collectMetadata() {
+    const metadata = {
+      yp_client_time: Date.now(),
+      yp_platform: Platform.OS,
+      yp_platform_version: String(Platform.Version),
+      yp_user_agent: buildUserAgent(),
+      yp_timezone_offset: (/* @__PURE__ */ new Date()).getTimezoneOffset()
+    };
+    try {
+      metadata.yp_timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch {
+    }
+    if (this.cid) metadata.google_client_id = this.cid;
+    return metadata;
+  }
+  async flush() {
+    await this.ready();
+    await this.beacon?.flush();
+    return this;
+  }
+  async reset() {
+    await this.ready();
+    this.userId = null;
+    this.userProperties = {};
+    await clearUser();
+    await Storage.removeItem(StorageKeys.PENDING_EVENTS);
+    await Storage.removeItem(StorageKeys.ATTRIBUTION);
+    const newSession = generateId();
+    this.sessionId = newSession;
+    await saveSession(newSession);
+    this.log("Reset");
+    return this;
+  }
+  teardown() {
+    this.appStateSubscription?.remove();
+    this.appStateSubscription = null;
+  }
+  log(message, data) {
+    if (this.config.debug) {
+      console.log(`[YesPlz Analytics] ${message}`, data ?? "");
+    }
+  }
+};
+var globalRef = globalThis;
+var analytics = globalRef.__yesplz_analytics_rn__ || (globalRef.__yesplz_analytics_rn__ = new Analytics());
+export {
+  Analytics,
+  EventType,
+  ItemListId,
+  VERSION,
+  analytics,
+  normalizeItemListId
+};
+//# sourceMappingURL=index.js.map