pishoniq-tracker 0.0.0-stage → 2.0.0

package/dist/chunk-PDDJOQBE.js

@@ -0,0 +1,625 @@
+'use strict';
+
+// src/session.ts
+var SESSION_ID_KEY = "pishoniq_session_id";
+var SESSION_LAST_ACTIVE_KEY = "pishoniq_session_last_active";
+var SESSION_STARTED_KEY = "pishoniq_session_started";
+var INACTIVITY_MS = 30 * 60 * 1e3;
+var TOUCH_WRITE_THROTTLE_MS = 1e3;
+var cachedSessionId = null;
+var cachedLastActive = 0;
+var cachedStartedAt = 0;
+var lastTouchWrite = 0;
+function isBrowser() {
+  return typeof window !== "undefined" && typeof localStorage !== "undefined";
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function readLastActive() {
+  if (!isBrowser()) return 0;
+  if (cachedLastActive) return cachedLastActive;
+  const raw = localStorage.getItem(SESSION_LAST_ACTIVE_KEY);
+  cachedLastActive = raw ? Number(raw) : 0;
+  return cachedLastActive;
+}
+function writeSession(sessionId, startedAt) {
+  if (!isBrowser()) return;
+  const now = Date.now();
+  cachedSessionId = sessionId;
+  cachedStartedAt = startedAt;
+  cachedLastActive = now;
+  lastTouchWrite = now;
+  try {
+    localStorage.setItem(SESSION_ID_KEY, sessionId);
+    localStorage.setItem(SESSION_STARTED_KEY, String(startedAt));
+    localStorage.setItem(SESSION_LAST_ACTIVE_KEY, String(now));
+  } catch {
+  }
+}
+function getSessionId() {
+  if (!isBrowser()) return "";
+  const now = Date.now();
+  if (cachedSessionId && cachedLastActive && now - cachedLastActive < INACTIVITY_MS) {
+    return cachedSessionId;
+  }
+  const existingId = cachedSessionId ?? localStorage.getItem(SESSION_ID_KEY);
+  const lastActive = readLastActive();
+  if (existingId && lastActive && now - lastActive < INACTIVITY_MS) {
+    cachedSessionId = existingId;
+    return existingId;
+  }
+  const newId = generateUUID();
+  writeSession(newId, now);
+  return newId;
+}
+function touchSession() {
+  if (!isBrowser()) return;
+  const now = Date.now();
+  cachedLastActive = now;
+  if (now - lastTouchWrite < TOUCH_WRITE_THROTTLE_MS) return;
+  lastTouchWrite = now;
+  try {
+    localStorage.setItem(SESSION_LAST_ACTIVE_KEY, String(now));
+  } catch {
+  }
+}
+function resetSession() {
+  const sessionId = generateUUID();
+  writeSession(sessionId, Date.now());
+  return { sessionId, isNew: true };
+}
+function ensureSession() {
+  if (!isBrowser()) {
+    return { sessionId: "", isNew: false };
+  }
+  const now = Date.now();
+  const existingId = cachedSessionId ?? localStorage.getItem(SESSION_ID_KEY);
+  const lastActive = readLastActive();
+  if (existingId && lastActive && now - lastActive < INACTIVITY_MS) {
+    cachedSessionId = existingId;
+    touchSession();
+    return { sessionId: existingId, isNew: false };
+  }
+  const { sessionId } = resetSession();
+  return { sessionId, isNew: true };
+}
+function getSessionStartedAt() {
+  if (!isBrowser()) return Date.now();
+  if (cachedStartedAt) return cachedStartedAt;
+  const raw = localStorage.getItem(SESSION_STARTED_KEY);
+  cachedStartedAt = raw ? Number(raw) : Date.now();
+  return cachedStartedAt;
+}
+function getSessionDurationMs() {
+  return Date.now() - getSessionStartedAt();
+}
+function _resetSessionCache() {
+  cachedSessionId = null;
+  cachedLastActive = 0;
+  cachedStartedAt = 0;
+  lastTouchWrite = 0;
+}
+
+// src/network.ts
+var DEFAULT_FLUSH_INTERVAL_MS = 2e3;
+var DEFAULT_MAX_BATCH_SIZE = 100;
+var DEFAULT_MAX_QUEUE_SIZE = 1e3;
+var MAX_RETRIES = 3;
+var MAX_PENDING_RETRIES = 3;
+var RETRY_DELAYS_MS = [1e3, 2e3, 4e3];
+var config = null;
+var queue = [];
+var flushTimer = null;
+var pendingRetries = 0;
+var debugMode = false;
+var unloadHandlersAttached = false;
+var droppedCount = 0;
+var cachedUserAgent = null;
+var needsSessionFill = false;
+function log(...args) {
+  if (debugMode) console.log("[PishonIQ]", ...args);
+}
+function warn(...args) {
+  if (debugMode) console.warn("[PishonIQ]", ...args);
+}
+function setDebugMode(value) {
+  debugMode = value;
+}
+function isBrowser2() {
+  return typeof window !== "undefined";
+}
+function getMeta() {
+  if (!isBrowser2()) {
+    return { url: "", userAgent: "" };
+  }
+  if (cachedUserAgent === null) {
+    cachedUserAgent = navigator.userAgent;
+  }
+  return {
+    url: window.location.href,
+    userAgent: cachedUserAgent
+  };
+}
+function flushIntervalMs() {
+  return config?.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+}
+function maxBatchSize() {
+  return config?.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE;
+}
+function maxQueueSize() {
+  return config?.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+}
+function startFlushTimer() {
+  if (!isBrowser2() || flushTimer) return;
+  flushTimer = setInterval(() => {
+    void flush(false);
+  }, flushIntervalMs());
+}
+function stopFlushTimer() {
+  if (flushTimer) {
+    clearInterval(flushTimer);
+    flushTimer = null;
+  }
+}
+function onVisibilityChange() {
+  if (typeof document === "undefined") return;
+  if (document.visibilityState === "hidden") {
+    flush(true);
+    stopFlushTimer();
+  } else {
+    startFlushTimer();
+  }
+}
+function onBeforeUnload() {
+  flush(true);
+}
+function initNetwork(networkConfig) {
+  config = networkConfig;
+  if (!isBrowser2()) return;
+  stopFlushTimer();
+  startFlushTimer();
+  if (!unloadHandlersAttached) {
+    unloadHandlersAttached = true;
+    window.addEventListener("beforeunload", onBeforeUnload);
+    document.addEventListener("visibilitychange", onVisibilityChange);
+  }
+  log(`Network ready | endpoint: ${networkConfig.host}/api/events | flush every ${flushIntervalMs()}ms`);
+}
+function shutdownNetwork() {
+  stopFlushTimer();
+  if (isBrowser2() && unloadHandlersAttached) {
+    unloadHandlersAttached = false;
+    window.removeEventListener("beforeunload", onBeforeUnload);
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+  }
+  config = null;
+  queue = [];
+  pendingRetries = 0;
+  droppedCount = 0;
+  needsSessionFill = false;
+}
+function enqueueEvent(event, properties) {
+  if (!config) {
+    warn("enqueueEvent called before init \u2014 event dropped:", event);
+    return;
+  }
+  const sampleRate = config.sampleRate ?? 1;
+  const isCritical = event === "identify" || event === "session_start" || event === "session_end";
+  if (!isCritical && sampleRate < 1 && Math.random() > sampleRate) return;
+  touchSession();
+  const payload = {
+    sessionId: getSessionId(),
+    userId: config.getUserId(),
+    event,
+    properties,
+    timestamp: Date.now(),
+    schemaVersion: 1,
+    ...getMeta()
+  };
+  queue.push(payload);
+  if (!payload.sessionId) needsSessionFill = true;
+  if (queue.length > maxQueueSize()) {
+    const overflow = queue.length - maxQueueSize();
+    queue.splice(0, overflow);
+    droppedCount += overflow;
+    if (debugMode) warn(`Queue full \u2014 dropped ${overflow} oldest event(s) (${droppedCount} total)`);
+  }
+  if (debugMode) log(`Event queued: "${event}" | queue size: ${queue.length}`, properties ?? "");
+  if (queue.length >= maxBatchSize()) {
+    if (debugMode) log(`Queue reached max batch size (${maxBatchSize()}) \u2014 flushing immediately`);
+    flush(false);
+  }
+}
+function setEnqueueSessionId(sessionId) {
+  if (!needsSessionFill) return;
+  for (const item of queue) {
+    if (!item.sessionId) {
+      item.sessionId = sessionId;
+    }
+  }
+  needsSessionFill = false;
+}
+function stampBatch(items, sessionId, userId2) {
+  const out = new Array(items.length);
+  for (let i = 0; i < items.length; i++) {
+    const e = items[i];
+    out[i] = {
+      ...e,
+      sessionId: e.sessionId || sessionId,
+      userId: e.userId ?? userId2
+    };
+  }
+  return out;
+}
+function getEndpoint() {
+  const host2 = (config?.host ?? "").replace(/\/$/, "");
+  return `${host2}/api/events`;
+}
+async function postBatch(events, useBeacon) {
+  if (!config || events.length === 0) return { ok: true, retryable: false };
+  const url = getEndpoint();
+  const body = { events };
+  try {
+    log(`Flushing ${events.length} event(s) \u2192 ${url}`);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.apiKey}`
+      },
+      body: JSON.stringify(body),
+      keepalive: useBeacon
+    });
+    if (response.ok) {
+      log(`\u2713 Sent ${events.length} event(s) successfully`);
+      return { ok: true, retryable: false, status: response.status };
+    }
+    warn(`\u2717 Server rejected events | HTTP ${response.status} | url: ${url}`);
+    if (response.status === 401) {
+      warn("\u2717 Invalid apiKey \u2014 events will not be retried. Check the apiKey passed to PishonIQ.init().");
+      return { ok: false, retryable: false, status: response.status };
+    }
+    if (response.status === 400) {
+      return { ok: false, retryable: false, status: response.status };
+    }
+    return { ok: false, retryable: true, status: response.status };
+  } catch (err) {
+    warn(`\u2717 Network error \u2014 backend unreachable at ${url}`, err instanceof Error ? err.message : err);
+    return { ok: false, retryable: true };
+  }
+}
+function scheduleRetry(events, attempt) {
+  if (attempt >= MAX_RETRIES) {
+    warn(`Gave up after ${MAX_RETRIES} retries \u2014 ${events.length} event(s) lost`);
+    return;
+  }
+  if (pendingRetries >= MAX_PENDING_RETRIES) {
+    warn(`Too many pending retries \u2014 dropping batch of ${events.length} event(s)`);
+    return;
+  }
+  const delay = RETRY_DELAYS_MS[attempt] ?? 4e3;
+  warn(`Retrying in ${delay}ms (attempt ${attempt + 1}/${MAX_RETRIES})`);
+  pendingRetries += 1;
+  setTimeout(() => {
+    pendingRetries -= 1;
+    void (async () => {
+      const result = await postBatch(events, false);
+      if (!result.ok && result.retryable) {
+        scheduleRetry(events, attempt + 1);
+      }
+    })();
+  }, delay);
+}
+function flush(useBeacon = false) {
+  if (!config || queue.length === 0) return;
+  const batch = queue;
+  queue = [];
+  const sessionId = batch[0]?.sessionId || (typeof window !== "undefined" ? localStorage.getItem(SESSION_ID_KEY) ?? "" : "");
+  if (debugMode) log(`Flushing ${batch.length} event(s) | sessionId: ${sessionId} | useBeacon: ${useBeacon}`);
+  const events = stampBatch(batch, sessionId, config?.getUserId());
+  void (async () => {
+    const result = await postBatch(events, useBeacon);
+    if (!result.ok && !useBeacon && result.retryable) {
+      scheduleRetry(events, 0);
+    }
+  })();
+}
+
+// src/tracker.ts
+var SCROLL_MILESTONES = [25, 50, 75, 100];
+var started = false;
+var historyPatched = false;
+var lastPageUrl = "";
+var initialPageSent = false;
+var reactRouterActive = false;
+var sessionEndSent = false;
+var captureConfig = {
+  clicks: true,
+  pageViews: true,
+  scrollDepth: true,
+  sessions: true
+};
+var reachedScrollDepths = /* @__PURE__ */ new Set();
+function isBrowser3() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function getClickTarget(event) {
+  const target = event.target;
+  if (!(target instanceof Element)) return null;
+  return target.closest("[data-pishon], button, a, input[type='button'], input[type='submit']");
+}
+function getClickProperties(el) {
+  const text = (el.textContent ?? "").trim().slice(0, 200);
+  const props = {
+    tag: el.tagName,
+    text
+  };
+  if (el instanceof HTMLAnchorElement && el.href) {
+    props.href = el.href;
+  }
+  const dataPishon = el.getAttribute("data-pishon");
+  if (dataPishon) {
+    props.pishon = dataPishon;
+  }
+  return props;
+}
+function emitPageView(pageName, source = "auto") {
+  if (!isBrowser3() || !captureConfig.pageViews) return;
+  const url = window.location.href;
+  if (url === lastPageUrl && initialPageSent) {
+    return;
+  }
+  lastPageUrl = url;
+  initialPageSent = true;
+  reachedScrollDepths.clear();
+  enqueueEvent("page_view", {
+    pageName: pageName ?? document.title,
+    pathname: window.location.pathname,
+    search: window.location.search,
+    referrer: document.referrer || void 0,
+    source
+  });
+}
+function onHistoryChange() {
+  if (reactRouterActive) return;
+  emitPageView(void 0, "history");
+}
+function patchHistory() {
+  if (!isBrowser3() || historyPatched) return;
+  historyPatched = true;
+  const originalPushState = history.pushState.bind(history);
+  const originalReplaceState = history.replaceState.bind(history);
+  history.pushState = function(...args) {
+    originalPushState(...args);
+    onHistoryChange();
+  };
+  history.replaceState = function(...args) {
+    originalReplaceState(...args);
+    onHistoryChange();
+  };
+  window.addEventListener("popstate", onHistoryChange);
+}
+function onClick(event) {
+  if (!captureConfig.clicks) return;
+  const el = getClickTarget(event);
+  if (!el) return;
+  enqueueEvent("click", getClickProperties(el));
+}
+function getScrollPercent() {
+  const doc = document.documentElement;
+  const scrollTop = window.scrollY || doc.scrollTop;
+  const scrollHeight = doc.scrollHeight - doc.clientHeight;
+  if (scrollHeight <= 0) return 100;
+  return Math.min(100, Math.round(scrollTop / scrollHeight * 100));
+}
+var scrollScheduled = false;
+function onScroll() {
+  if (!captureConfig.scrollDepth || scrollScheduled) return;
+  scrollScheduled = true;
+  requestAnimationFrame(() => {
+    scrollScheduled = false;
+    const percent = getScrollPercent();
+    for (const milestone of SCROLL_MILESTONES) {
+      if (percent >= milestone && !reachedScrollDepths.has(milestone)) {
+        reachedScrollDepths.add(milestone);
+        enqueueEvent("scroll_depth", { depth: milestone, percent });
+      }
+    }
+  });
+}
+function onSessionEnd() {
+  if (!captureConfig.sessions || sessionEndSent) return;
+  sessionEndSent = true;
+  enqueueEvent("session_end", { durationMs: getSessionDurationMs() });
+  flush(true);
+}
+function setReactRouterActive(active) {
+  reactRouterActive = active;
+}
+function startAutoCapture(options) {
+  if (!isBrowser3() || started) return;
+  if (options) {
+    captureConfig = {
+      clicks: options.clicks ?? true,
+      pageViews: options.pageViews ?? true,
+      scrollDepth: options.scrollDepth ?? true,
+      sessions: options.sessions ?? true
+    };
+  }
+  started = true;
+  sessionEndSent = false;
+  const { isNew } = ensureSession();
+  if (isNew && captureConfig.sessions) {
+    enqueueEvent("session_start", {
+      referrer: document.referrer || void 0
+    });
+  }
+  patchHistory();
+  emitPageView(void 0, "initial");
+  if (captureConfig.clicks) {
+    document.addEventListener("click", onClick, true);
+  }
+  if (captureConfig.scrollDepth) {
+    window.addEventListener("scroll", onScroll, { passive: true });
+  }
+  if (captureConfig.sessions) {
+    window.addEventListener("beforeunload", onSessionEnd);
+    window.addEventListener("pagehide", onSessionEnd);
+  }
+}
+function stopAutoCapture() {
+  if (!isBrowser3() || !started) return;
+  started = false;
+  sessionEndSent = false;
+  document.removeEventListener("click", onClick, true);
+  window.removeEventListener("scroll", onScroll);
+  window.removeEventListener("beforeunload", onSessionEnd);
+  window.removeEventListener("pagehide", onSessionEnd);
+}
+function trackPage(pageName) {
+  emitPageView(pageName, "manual");
+}
+function refreshSessionAfterIdentify() {
+  touchSession();
+}
+
+// src/index.ts
+var USER_ID_KEY = "pishoniq_user_id";
+var USER_TRAITS_KEY = "pishoniq_user_traits";
+var LOCALHOST_RE = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?\/?$/i;
+var initialized = false;
+var apiKey = "";
+var host = "";
+var userId;
+var userTraits;
+function isBrowser4() {
+  return typeof window !== "undefined";
+}
+function loadPersistedUser() {
+  if (!isBrowser4()) return;
+  userId = localStorage.getItem(USER_ID_KEY) ?? void 0;
+  const traitsRaw = localStorage.getItem(USER_TRAITS_KEY);
+  if (traitsRaw) {
+    try {
+      userTraits = JSON.parse(traitsRaw);
+    } catch {
+      userTraits = void 0;
+    }
+  }
+}
+function persistUser(id, traits) {
+  if (!isBrowser4()) return;
+  localStorage.setItem(USER_ID_KEY, id);
+  if (traits) {
+    localStorage.setItem(USER_TRAITS_KEY, JSON.stringify(traits));
+  }
+}
+function assertInitialized() {
+  if (!initialized) {
+    throw new Error("[PishonIQ] Call PishonIQ.init() before using the SDK");
+  }
+}
+var PishonIQ = class {
+  static isInitialized() {
+    return initialized;
+  }
+  static init(options) {
+    if (!options.apiKey) {
+      throw new Error("[PishonIQ] apiKey is required");
+    }
+    if (!options.host) {
+      throw new Error("[PishonIQ] host is required \u2014 pass the URL of your PishonIQ backend");
+    }
+    const sampleRate = options.sampleRate ?? 1;
+    if (!(sampleRate >= 0 && sampleRate <= 1)) {
+      throw new Error("[PishonIQ] sampleRate must be between 0 and 1");
+    }
+    if (initialized) {
+      console.warn("[PishonIQ] init() called more than once; ignoring");
+      return;
+    }
+    if (LOCALHOST_RE.test(options.host)) {
+      console.warn(
+        `[PishonIQ] host "${options.host}" looks like a local address \u2014 make sure to pass your production backend URL in deployed environments`
+      );
+    }
+    apiKey = options.apiKey;
+    host = options.host.replace(/\/$/, "");
+    initialized = true;
+    setDebugMode(options.debug ?? false);
+    if (options.debug) {
+      const masked = `${apiKey.slice(0, 6)}...${apiKey.slice(-4)}`;
+      console.log(`[PishonIQ] Initialized | apiKey: ${masked} | host: ${host} | debug: true`);
+    }
+    loadPersistedUser();
+    const { sessionId } = ensureSession();
+    initNetwork({
+      apiKey,
+      host,
+      getUserId: () => userId,
+      flushIntervalMs: options.flushIntervalMs,
+      maxBatchSize: options.maxBatchSize,
+      maxQueueSize: options.maxQueueSize,
+      sampleRate
+    });
+    setEnqueueSessionId(sessionId);
+    if (isBrowser4()) {
+      startAutoCapture(options.autoCapture);
+    }
+  }
+  static track(event, properties) {
+    assertInitialized();
+    if (!isBrowser4()) return;
+    touchSession();
+    setEnqueueSessionId(getSessionId());
+    enqueueEvent(event, properties);
+  }
+  static identify(id, traits) {
+    assertInitialized();
+    if (!isBrowser4()) return;
+    userId = id;
+    userTraits = traits;
+    persistUser(id, traits);
+    refreshSessionAfterIdentify();
+    touchSession();
+    setEnqueueSessionId(getSessionId());
+    enqueueEvent("identify", {
+      userId: id,
+      traits: traits ?? userTraits
+    });
+  }
+  static page(pageName) {
+    assertInitialized();
+    if (!isBrowser4()) return;
+    touchSession();
+    setEnqueueSessionId(getSessionId());
+    trackPage(pageName);
+  }
+  /** @internal Used by React integration to avoid duplicate page_view events */
+  static _setReactRouterActive(active) {
+    setReactRouterActive(active);
+  }
+  /** @internal Reset SDK state (testing only) */
+  static _reset() {
+    initialized = false;
+    apiKey = "";
+    host = "";
+    userId = void 0;
+    userTraits = void 0;
+    stopAutoCapture();
+    shutdownNetwork();
+    _resetSessionCache();
+  }
+};
+var index_default = PishonIQ;
+
+exports.PishonIQ = PishonIQ;
+exports.index_default = index_default;