@agroideas/event-tracker-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,749 @@
+'use strict';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  destroy: () => destroy,
+  flush: () => flush,
+  identify: () => identify,
+  init: () => init,
+  tracker: () => tracker
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/EventBuffer.ts
+var BATCH_INTERVAL = 1e4;
+var MAX_BUFFER_SIZE = 15;
+var EventBuffer = class {
+  constructor(config) {
+    this._flushTimer = null;
+    this._buffer = [];
+    this._endpoint = config.endpoint;
+    this._apiKey = config.apiKey;
+    this._isDebug = config.debug == "true";
+    console.log(config);
+    this._config = {
+      batchInterval: config.batchInterval ?? BATCH_INTERVAL,
+      maxBufferSize: config.maxBufferSize ?? MAX_BUFFER_SIZE
+    };
+    if (this._isDebug) {
+      console.log("[EventTracker] Modo DEBUG activado");
+      console.log("[EventTracker] Endpoint:", this._endpoint);
+      console.log("[EventTracker] API Key:", this._apiKey);
+    }
+    if (!this._isDebug) {
+      this._startFlushTimer();
+    }
+    this._setupVisibilityListener();
+  }
+  /** Agrega un evento al buffer */
+  add(event) {
+    try {
+      this._buffer.push(event);
+      if (this._isDebug) {
+        console.log("[EventTracker] Evento agregado:", event.eventType);
+        console.log("[EventTracker] Buffer size:", this._buffer.length);
+        console.log("[EventTracker] Event content:", JSON.stringify(event, null, 2));
+      }
+      if (!this._isDebug && this._buffer.length >= this._config.maxBufferSize) {
+        this.flush();
+      }
+    } catch {
+    }
+  }
+  /** Envía todos los eventos acumulados al servidor */
+  async flush() {
+    try {
+      if (this._buffer.length === 0) {
+        return { success: true };
+      }
+      const eventsToSend = [...this._buffer];
+      this._buffer = [];
+      if (this._isDebug) {
+        console.log("[EventTracker] DEBUG - Events:", JSON.stringify(eventsToSend, null, 2));
+        return { success: true };
+      }
+      const result = await this._sendEventsAsync(eventsToSend);
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /** Obtiene la cantidad de eventos en el buffer */
+  getSize() {
+    return this._buffer.length;
+  }
+  /** Limpia el buffer sin enviar */
+  clear() {
+    this._buffer = [];
+  }
+  /** Destruye el buffer y limpia recursos */
+  destroy() {
+    if (this._flushTimer) {
+      clearInterval(this._flushTimer);
+      this._flushTimer = null;
+    }
+    this._buffer = [];
+  }
+  /** Inicia el temporizador de flush periódico */
+  _startFlushTimer() {
+    this._flushTimer = setInterval(() => {
+      if (this._buffer.length > 0) {
+        this.flush();
+      }
+    }, this._config.batchInterval);
+  }
+  /** Configura el listener de visibilitychange para envío de emergencia */
+  _setupVisibilityListener() {
+    if (typeof document === "undefined") {
+      return;
+    }
+    const handleVisibilityChange = () => {
+      if (this._isDebug) {
+        return;
+      }
+      if (document.visibilityState === "hidden" && this._buffer.length > 0) {
+        setTimeout(() => {
+          this.flush();
+        }, 0);
+      }
+    };
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+  }
+  /** Envía eventos usando fetch con keepalive (funciona incluso en page unload) */
+  async _sendEventsAsync(events) {
+    try {
+      const payload = JSON.stringify({
+        apiKey: this._apiKey,
+        events
+      });
+      const response = await fetch(this._endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: payload,
+        keepalive: true
+      });
+      let message;
+      try {
+        const responseData = await response.json();
+        message = responseData.message;
+      } catch {
+        message = response.statusText;
+      }
+      return {
+        success: response.ok,
+        statusCode: response.status,
+        message
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Network error"
+      };
+    }
+  }
+};
+
+// src/utils/uuid.ts
+function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
+    const random = Math.random() * 16 | 0;
+    const value = char === "x" ? random : random & 3 | 8;
+    return value.toString(16);
+  });
+}
+
+// src/utils/truncate.ts
+function truncate(text, maxLength) {
+  if (maxLength < 3) {
+    return "...";
+  }
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.substring(0, maxLength - 3) + "...";
+}
+
+// src/utils/metadata.ts
+function getOrCreateSessionId() {
+  try {
+    const storageKey = "event_tracker_session_id";
+    const existingSessionId = sessionStorage.getItem(storageKey);
+    if (existingSessionId) {
+      return existingSessionId;
+    }
+    const newSessionId = generateUUID();
+    sessionStorage.setItem(storageKey, newSessionId);
+    return newSessionId;
+  } catch {
+    return generateUUID();
+  }
+}
+function getScreenSize() {
+  if (typeof window === "undefined") {
+    return "0x0";
+  }
+  return `${window.innerWidth}x${window.innerHeight}`;
+}
+function getViewportSize() {
+  if (typeof window === "undefined") {
+    return "0x0";
+  }
+  return `${window.innerWidth}x${window.innerHeight}`;
+}
+function getDeviceType() {
+  if (typeof navigator === "undefined") {
+    return "unknown";
+  }
+  const ua = navigator.userAgent;
+  if (/(tablet|ipad|playbook|silk)|(android(?!.*mobi))/i.test(ua)) {
+    return "tablet";
+  }
+  if (/Mobile|Android|iP(hone|od)|IEMobile|BlackBerry|Kindle|Silk-Accelerated|(hpw|web)OS|Opera M(obi|ini)/.test(ua)) {
+    return "mobile";
+  }
+  return "desktop";
+}
+function getBrowser() {
+  if (typeof navigator === "undefined") {
+    return "unknown";
+  }
+  const ua = navigator.userAgent;
+  if (ua.includes("Firefox")) {
+    return "Firefox";
+  }
+  if (ua.includes("Edg/")) {
+    return "Edge";
+  }
+  if (ua.includes("Chrome")) {
+    return "Chrome";
+  }
+  if (ua.includes("Safari")) {
+    return "Safari";
+  }
+  if (ua.includes("MSIE") || ua.includes("Trident/")) {
+    return "Internet Explorer";
+  }
+  return "unknown";
+}
+function getOS() {
+  if (typeof navigator === "undefined") {
+    return "unknown";
+  }
+  const ua = navigator.userAgent;
+  if (ua.includes("Windows")) {
+    return "Windows";
+  }
+  if (ua.includes("Mac OS")) {
+    return "macOS";
+  }
+  if (ua.includes("Linux")) {
+    return "Linux";
+  }
+  if (ua.includes("Android")) {
+    return "Android";
+  }
+  if (ua.includes("iOS") || ua.includes("iPhone") || ua.includes("iPad")) {
+    return "iOS";
+  }
+  return "unknown";
+}
+function getLanguage() {
+  if (typeof navigator === "undefined") {
+    return "unknown";
+  }
+  return navigator.language || "unknown";
+}
+function getReferrer() {
+  if (typeof window === "undefined") {
+    return "";
+  }
+  return document.referrer;
+}
+function getTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function getCurrentPath() {
+  if (typeof window === "undefined") {
+    return "";
+  }
+  return window.location.pathname;
+}
+
+// src/observers/ClickObserver.ts
+var TRACKABLE_TAGS = ["BUTTON", "A", "INPUT", "I", "SPAN", "DIV"];
+var TRACKABLE_INPUT_TYPES = ["submit"];
+var SENSITIVE_INPUT_TYPES = ["password", "email", "tel", "number", "search", "url"];
+var TRACKABLE_SELECTORS = [
+  "button",
+  "a",
+  'input[type="submit"]',
+  "[data-track]",
+  '[style*="cursor: pointer"]',
+  'i[class*="mdi-"]'
+];
+function _isSensitiveElement(element) {
+  if (element.tagName === "INPUT") {
+    const inputType = element.type?.toLowerCase() ?? "";
+    return SENSITIVE_INPUT_TYPES.includes(inputType);
+  }
+  return false;
+}
+function _isTrackableElement(element) {
+  const tagName = element.tagName.toUpperCase();
+  if (!TRACKABLE_TAGS.includes(tagName)) {
+    return element.hasAttribute("data-track") || _hasCursorPointer(element) || _isMdiIcon(element);
+  }
+  if (tagName === "INPUT") {
+    const inputType = element.type?.toLowerCase() ?? "";
+    return TRACKABLE_INPUT_TYPES.includes(inputType);
+  }
+  return true;
+}
+function _hasCursorPointer(element) {
+  try {
+    const style = window.getComputedStyle(element);
+    return style.cursor === "pointer";
+  } catch {
+    return false;
+  }
+}
+function _isMdiIcon(element) {
+  return element.tagName === "I" && element.classList.contains("mdi");
+}
+function _generateSelector(element) {
+  const parts = [];
+  let current = element;
+  while (current && current !== document.documentElement) {
+    let selector = current.tagName.toLowerCase();
+    if (current.id) {
+      selector += `#${current.id}`;
+      parts.unshift(selector);
+      break;
+    } else if (current.className && typeof current.className === "string") {
+      const classes = current.className.trim().split(/\s+/).filter(Boolean);
+      if (classes.length > 0) {
+        selector += `.${classes[0]}`;
+      }
+    }
+    parts.unshift(selector);
+    current = current.parentElement;
+  }
+  return parts.slice(0, 4).join(" > ");
+}
+function _getAllClasses(element) {
+  if (!element.className || typeof element.className !== "string") {
+    return void 0;
+  }
+  const classes = element.className.trim().split(/\s+/).filter(Boolean);
+  return classes.length > 0 ? classes.join(" ") : void 0;
+}
+var ClickObserver = class {
+  constructor(tracker2) {
+    this._isActive = false;
+    this._tracker = tracker2;
+    this._boundHandleClick = this._handleClick.bind(this);
+  }
+  /** Inicia el observer */
+  start() {
+    if (this._isActive) {
+      return;
+    }
+    try {
+      window.addEventListener("click", this._boundHandleClick, true);
+      this._isActive = true;
+    } catch {
+    }
+  }
+  /** Detiene el observer */
+  stop() {
+    if (!this._isActive) {
+      return;
+    }
+    try {
+      window.removeEventListener("click", this._boundHandleClick, true);
+      this._isActive = false;
+    } catch {
+    }
+  }
+  /** Manejador de eventos de clic */
+  _handleClick(event) {
+    try {
+      const target = event.target;
+      if (!target) {
+        return;
+      }
+      if (_isTrackableElement(target) && !_isSensitiveElement(target)) {
+        this._createClickEvent(target);
+        return;
+      }
+      const trackableElement = target.closest(TRACKABLE_SELECTORS.join(","));
+      if (!trackableElement) {
+        return;
+      }
+      if (_isSensitiveElement(trackableElement)) {
+        return;
+      }
+      if (!_isTrackableElement(trackableElement)) {
+        return;
+      }
+      this._createClickEvent(trackableElement);
+    } catch {
+    }
+  }
+  /** Crea un evento de clic */
+  _createClickEvent(element) {
+    const event = {
+      eventType: "user_click",
+      eventId: generateUUID(),
+      context: {
+        sessionId: "",
+        userId: null,
+        userName: null,
+        url: window.location.href,
+        referrer: getReferrer(),
+        screenSize: getScreenSize(),
+        viewportSize: getViewportSize(),
+        deviceType: getDeviceType(),
+        browser: getBrowser(),
+        os: getOS(),
+        language: getLanguage(),
+        timestamp: getTimestamp()
+      },
+      data: {
+        tagName: element.tagName,
+        id: element.id || void 0,
+        className: _getAllClasses(element),
+        title: element.getAttribute("title") || void 0,
+        text: element.textContent ? truncate(element.textContent, 30) : void 0,
+        selector: _generateSelector(element)
+      }
+    };
+    this._tracker.trackEvent(event);
+  }
+};
+
+// src/observers/HistoryObserver.ts
+var HistoryObserver = class {
+  constructor(tracker2) {
+    this._isActive = false;
+    this._tracker = tracker2;
+    this._lastFocusTime = Date.now();
+    this._accumulatedFocusTime = 0;
+    this._boundHandlePopState = this._handlePopState.bind(this);
+  }
+  /** Inicia el observer */
+  start() {
+    if (this._isActive) {
+      return;
+    }
+    try {
+      this._patchHistoryMethods();
+      window.addEventListener("popstate", this._boundHandlePopState);
+      window.addEventListener("beforeunload", this._handleBeforeUnload);
+      window.addEventListener("focus", this._handleFocus);
+      window.addEventListener("blur", this._handleBlur);
+      this._isActive = true;
+    } catch {
+    }
+  }
+  /** Detiene el observer */
+  stop() {
+    if (!this._isActive) {
+      return;
+    }
+    try {
+      this._restoreHistoryMethods();
+      window.removeEventListener("popstate", this._boundHandlePopState);
+      window.removeEventListener("beforeunload", this._handleBeforeUnload);
+      window.removeEventListener("focus", this._handleFocus);
+      window.removeEventListener("blur", this._handleBlur);
+      this._isActive = false;
+    } catch {
+    }
+  }
+  /** Aplica monkey-patch a los métodos history */
+  _patchHistoryMethods() {
+    const historyWithTracking = history;
+    if (!historyWithTracking._originalPushState) {
+      historyWithTracking._originalPushState = history.pushState;
+      history.pushState = this._wrappedPushState.bind(this);
+    }
+    if (!historyWithTracking._originalReplaceState) {
+      historyWithTracking._originalReplaceState = history.replaceState;
+      history.replaceState = this._wrappedReplaceState.bind(this);
+    }
+  }
+  /** Restaura los métodos originales */
+  _restoreHistoryMethods() {
+    const historyWithTracking = history;
+    if (historyWithTracking._originalPushState) {
+      history.pushState = historyWithTracking._originalPushState;
+      historyWithTracking._originalPushState = void 0;
+    }
+    if (historyWithTracking._originalReplaceState) {
+      history.replaceState = historyWithTracking._originalReplaceState;
+      historyWithTracking._originalReplaceState = void 0;
+    }
+  }
+  /** Wrapper para pushState */
+  _wrappedPushState(state, title, url) {
+    try {
+      const historyWithTracking = history;
+      historyWithTracking._originalPushState?.call(history, state, title, url);
+      this._handleNavigationChange();
+    } catch {
+    }
+  }
+  /** Wrapper para replaceState */
+  _wrappedReplaceState(state, title, url) {
+    try {
+      const historyWithTracking = history;
+      historyWithTracking._originalReplaceState?.call(history, state, title, url);
+      this._handleNavigationChange();
+    } catch {
+    }
+  }
+  /** Manejador de popstate */
+  _handlePopState() {
+    try {
+      this._handleNavigationChange();
+    } catch {
+    }
+  }
+  /** Manejador de focus (la ventana gagne foco) */
+  _handleFocus() {
+    try {
+      this._lastFocusTime = Date.now();
+    } catch {
+    }
+  }
+  /** Manejador de blur (la ventana pierde foco) */
+  _handleBlur() {
+    try {
+      this._accumulatedFocusTime += Date.now() - this._lastFocusTime;
+      this._lastFocusTime = Date.now();
+    } catch {
+    }
+  }
+  /** Manejador de beforeunload (cuando el usuario sale de la página) */
+  _handleBeforeUnload() {
+    try {
+      const duration = this._calculateFocusedDuration();
+      this._tracker.trackPageLeave(duration);
+    } catch {
+    }
+  }
+  /** Calcula la duración total con foco */
+  _calculateFocusedDuration() {
+    const currentTime = Date.now();
+    const hasFocus = document.hasFocus();
+    const focusedTime = this._accumulatedFocusTime + (hasFocus ? currentTime - this._lastFocusTime : 0);
+    return focusedTime / 1e3;
+  }
+  /** Maneja cambios de navegación (pushState, replaceState, popstate) */
+  _handleNavigationChange() {
+    try {
+      const duration = this._calculateFocusedDuration();
+      this._tracker.trackPageLeave(duration);
+      this._tracker.trackPageView();
+      this._lastFocusTime = Date.now();
+      this._accumulatedFocusTime = 0;
+    } catch {
+    }
+  }
+};
+
+// src/core/Tracker.ts
+var _Tracker = class _Tracker {
+  constructor() {
+    this._eventBuffer = null;
+    this._clickObserver = null;
+    this._historyObserver = null;
+    this._isInitialized = false;
+    this._userIdentity = {
+      userId: null,
+      userName: null
+    };
+    this._sessionId = getOrCreateSessionId();
+  }
+  /** Obtiene la instancia única del Tracker */
+  static getInstance() {
+    if (_Tracker._instance === null) {
+      _Tracker._instance = new _Tracker();
+    }
+    return _Tracker._instance;
+  }
+  /** Construye el contexto completo del evento */
+  _buildContext() {
+    return {
+      sessionId: this._sessionId,
+      userId: this._userIdentity.userId,
+      userName: this._userIdentity.userName,
+      url: window.location.href,
+      referrer: getReferrer(),
+      screenSize: getScreenSize(),
+      viewportSize: getViewportSize(),
+      deviceType: getDeviceType(),
+      browser: getBrowser(),
+      os: getOS(),
+      language: getLanguage(),
+      timestamp: getTimestamp()
+    };
+  }
+  /** Inicializa el tracker con la configuración */
+  init(config) {
+    try {
+      if (config.userId && config.userId != this._userIdentity.userId) {
+        this._userIdentity = {
+          userId: config.userId,
+          userName: config.userName ?? null
+        };
+        if (this._isInitialized && config.debug) {
+          console.log("[EventTracker] Usuario actualizado:", this._userIdentity);
+        }
+      }
+      if (this._isInitialized) {
+        return;
+      }
+      this._eventBuffer = new EventBuffer(config);
+      this._isInitialized = true;
+      this._clickObserver = new ClickObserver(this);
+      this._historyObserver = new HistoryObserver(this);
+      this._clickObserver.start();
+      this._historyObserver.start();
+      this.trackPageView();
+    } catch {
+    }
+  }
+  /** Identifica al usuario */
+  identify(userId, userName) {
+    try {
+      this._userIdentity = {
+        userId,
+        userName: userName ?? null
+      };
+    } catch {
+    }
+  }
+  /** Registra un evento */
+  trackEvent(event) {
+    try {
+      if (!this._eventBuffer) {
+        return;
+      }
+      const eventWithContext = {
+        ...event,
+        eventId: generateUUID(),
+        context: this._buildContext()
+      };
+      this._eventBuffer.add(eventWithContext);
+    } catch {
+    }
+  }
+  /** Crea un evento de page view */
+  trackPageView() {
+    try {
+      const event = {
+        eventType: "page_view",
+        eventId: generateUUID(),
+        context: this._buildContext(),
+        data: {
+          path: getCurrentPath()
+        }
+      };
+      this.trackEvent(event);
+    } catch {
+    }
+  }
+  /** Crea un evento de page leave */
+  trackPageLeave(duration) {
+    try {
+      const event = {
+        eventType: "page_leave",
+        eventId: generateUUID(),
+        context: this._buildContext(),
+        data: {
+          duration,
+          path: getCurrentPath()
+        }
+      };
+      this.trackEvent(event);
+    } catch {
+    }
+  }
+  /** Fuerza el envío de todos los eventos pendientes */
+  async flush() {
+    try {
+      if (this._eventBuffer) {
+        await this._eventBuffer.flush();
+      }
+    } catch {
+    }
+  }
+  /** Verifica si el tracker está inicializado */
+  isInitialized() {
+    return this._isInitialized;
+  }
+  /** Destruye el tracker */
+  destroy() {
+    try {
+      if (this._clickObserver) {
+        this._clickObserver.stop();
+        this._clickObserver = null;
+      }
+      if (this._historyObserver) {
+        this._historyObserver.stop();
+        this._historyObserver = null;
+      }
+      if (this._eventBuffer) {
+        this._eventBuffer.destroy();
+        this._eventBuffer = null;
+      }
+      this._isInitialized = false;
+    } catch {
+    }
+  }
+};
+_Tracker._instance = null;
+var Tracker2 = _Tracker;
+
+// src/index.ts
+var tracker = Tracker2.getInstance();
+function init(config) {
+  tracker.init(config);
+}
+function identify(userId, userName) {
+  tracker.identify(userId, userName);
+}
+function flush() {
+  return tracker.flush();
+}
+function destroy() {
+  tracker.destroy();
+}
+// Generated by tsup
+//# sourceMappingURL=index.js.map