userpath-js 0.0.0 → 0.0.1

package/dist/index.js

@@ -0,0 +1,997 @@
+// package.json
+var package_default = {
+  name: "userpath-js",
+  version: "0.0.0",
+  private: false,
+  main: "dist/index.js",
+  types: "dist/types/src/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/types/src/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./server": {
+      types: "./dist/types/src/server/index.d.ts",
+      default: "./dist/server/index.js"
+    }
+  },
+  files: [
+    "dist/index.js",
+    "dist/types",
+    "dist/server"
+  ],
+  scripts: {
+    dev: "bun build src/index.ts --outdir ./dist --watch",
+    types: "tsc",
+    build: "bun run build.client && bun run build.pixel && bun run build.server",
+    "build.prod": "bun run build.client.prod && bun run build.pixel.prod && bun run build.server.prod",
+    "build.client": "bun run types && bun build src/index.ts --outdir ./dist --no-cache",
+    "build.client.prod": "bun run types && bun build src/index.ts --outdir ./dist --minify",
+    "build.pixel": "bun build src/pixel.ts --outdir ./dist",
+    "build.pixel.prod": "bun build src/pixel.ts --outdir ./dist --minify",
+    "build.server": "bun run types && bun build src/server/index.ts --outdir ./dist/server",
+    "build.server.prod": "bun run types && bun build src/server/index.ts --outdir ./dist/server --minify",
+    prepublish: "bun run build.prod"
+  },
+  devDependencies: {
+    "bun-types": "latest",
+    typescript: "^5.0.0"
+  }
+};
+
+// src/schemas/config.ts
+var DEFAULT_CONFIG = {
+  appId: "",
+  serverUrl: "https://api.userpath.co",
+  version: 1,
+  flushIntervalMs: 5000,
+  autoTrack: {
+    errors: true,
+    clicks: true,
+    scrolling: true,
+    forms: true,
+    videos: true,
+    pageVisibility: true,
+    pageInactivity: true
+  }
+};
+
+// src/base/api.ts
+class ApiClient {
+  serverUrl;
+  appId;
+  version;
+  constructor(config) {
+    this.serverUrl = config.serverUrl || "";
+    this.appId = config.appId;
+    this.version = config.version || DEFAULT_CONFIG.version;
+  }
+  buildUrl(path) {
+    return `${this.serverUrl}/v${this.version}/${path}`;
+  }
+}
+
+// src/base/events.ts
+var isServer = typeof window === "undefined";
+var h = {
+  pushState: () => {},
+  replaceState: () => {},
+  go: () => {},
+  back: () => {},
+  forward: () => {}
+};
+if (isServer) {
+  global.history = h;
+}
+var w = {
+  location: {
+    href: ""
+  },
+  addEventListener: () => {},
+  removeEventListener: () => {},
+  scrollTo: () => {},
+  scrollBy: () => {},
+  setTimeout: () => {},
+  clearTimeout: () => {},
+  setInterval: () => {},
+  clearInterval: () => {}
+};
+if (isServer) {
+  global.window = w;
+}
+var d = {
+  hidden: false,
+  addEventListener: () => {},
+  removeEventListener: () => {},
+  querySelector: () => null,
+  closest: () => null,
+  getAttribute: () => null,
+  tagName: "",
+  textContent: "",
+  classList: {
+    contains: () => false
+  },
+  scrollHeight: 0,
+  offsetHeight: 0,
+  clientHeight: 0,
+  pageYOffset: 0,
+  referrer: "",
+  title: ""
+};
+if (isServer) {
+  global.document = d;
+}
+
+class EventsClient {
+  #session;
+  #trackedUrls;
+  #maxScroll;
+  #clickHandler;
+  #scrollHandler;
+  #resizeHandler;
+  #inputFocusHandler;
+  #inputBlurHandler;
+  #formChangeHandler;
+  #formSubmitHandler;
+  #videoPlayHandler;
+  #videoPauseHandler;
+  #videoEndHandler;
+  #visibilityChangeHandler;
+  #beforeUnloadHandler;
+  #scrollTimeout;
+  #currentUrl;
+  #formStartTimes;
+  #inputInitialValues;
+  #videoStartTimes;
+  #pageStartTime;
+  #pageVisibleTime;
+  #lastVisibilityChange;
+  #isPageVisible;
+  #lastActivityTime;
+  #inactivityTimeout;
+  #isUserInactive;
+  #activityHandler;
+  #inactivityThreshold = 60000;
+  #inactivityStartTime;
+  #errorHandlerInstalled = false;
+  #errorHandler;
+  #rejectionHandler;
+  #config;
+  constructor(session, config = DEFAULT_CONFIG) {
+    this.#session = session;
+    this.#config = config;
+    this.#trackedUrls = new Set;
+    this.#maxScroll = 0;
+    this.#scrollTimeout = null;
+    this.#currentUrl = window.location.href;
+    this.#formStartTimes = new Map;
+    this.#inputInitialValues = new WeakMap;
+    this.#videoStartTimes = new WeakMap;
+    this.#pageStartTime = Date.now();
+    this.#pageVisibleTime = 0;
+    this.#lastVisibilityChange = this.#pageStartTime;
+    this.#isPageVisible = document.hidden;
+    this.#lastActivityTime = Date.now();
+    this.#inactivityTimeout = null;
+    this.#isUserInactive = false;
+    this.#inactivityStartTime = null;
+    this.#clickHandler = this.handleClick.bind(this);
+    this.#scrollHandler = this.handleScroll.bind(this);
+    this.#resizeHandler = this.handleScroll.bind(this);
+    this.#inputFocusHandler = this.handleInputFocus.bind(this);
+    this.#inputBlurHandler = this.handleInputBlur.bind(this);
+    this.#formChangeHandler = this.handleFormChange.bind(this);
+    this.#formSubmitHandler = this.handleFormSubmit.bind(this);
+    this.#videoPlayHandler = this.handleVideoPlay.bind(this);
+    this.#videoPauseHandler = this.handleVideoPause.bind(this);
+    this.#videoEndHandler = this.handleVideoEnd.bind(this);
+    this.#visibilityChangeHandler = this.handleVisibilityChange.bind(this);
+    this.#beforeUnloadHandler = this.handleBeforeUnload.bind(this);
+    this.#activityHandler = this.handleUserActivity.bind(this);
+    this.#errorHandler = this.handleError.bind(this);
+    this.#rejectionHandler = this.handleRejection.bind(this);
+    const autoTrack = this.#config.autoTrack || DEFAULT_CONFIG.autoTrack;
+    if (autoTrack.clicks !== false) {
+      this.setupClickTracking();
+    }
+    if (autoTrack.scrolling !== false) {
+      this.setupScrollTracking();
+    }
+    if (autoTrack.forms !== false) {
+      this.setupFormTracking();
+    }
+    if (autoTrack.videos !== false) {
+      this.setupVideoTracking();
+    }
+    if (autoTrack.pageVisibility !== false) {
+      this.setupPageTimeTracking();
+    }
+    if (autoTrack.pageInactivity !== false) {
+      this.setupInactivityTracking();
+    }
+  }
+  destroy() {
+    document.removeEventListener("click", this.#clickHandler);
+    window.removeEventListener("scroll", this.#scrollHandler);
+    window.removeEventListener("resize", this.#resizeHandler);
+    document.removeEventListener("focus", this.#inputFocusHandler, true);
+    document.removeEventListener("blur", this.#inputBlurHandler, true);
+    document.removeEventListener("change", this.#formChangeHandler, true);
+    document.removeEventListener("submit", this.#formSubmitHandler, true);
+    document.removeEventListener("play", this.#videoPlayHandler, true);
+    document.removeEventListener("pause", this.#videoPauseHandler, true);
+    document.removeEventListener("ended", this.#videoEndHandler, true);
+    document.removeEventListener("visibilitychange", this.#visibilityChangeHandler);
+    window.removeEventListener("beforeunload", this.#beforeUnloadHandler);
+    if (this.#scrollTimeout) {
+      window.clearTimeout(this.#scrollTimeout);
+    }
+    ["mousemove", "mousedown", "keydown", "touchstart", "scroll"].forEach((eventType) => {
+      document.removeEventListener(eventType, this.#activityHandler, true);
+    });
+    if (this.#inactivityTimeout) {
+      window.clearTimeout(this.#inactivityTimeout);
+    }
+    this.uninstallErrorHandler();
+  }
+  setupClickTracking() {
+    document.addEventListener("click", this.#clickHandler);
+  }
+  handleClick(event) {
+    const element = event.target;
+    if (!element)
+      return;
+    const label = this.extractClickLabel(element);
+    if (!label)
+      return;
+    this.trackCustomEvent("click", {
+      label,
+      element: element.tagName.toLowerCase(),
+      id: element.id || undefined
+    });
+  }
+  handleScroll() {
+    const newUrl = window.location.href;
+    if (newUrl !== this.#currentUrl) {
+      this.#currentUrl = newUrl;
+      this.#maxScroll = 0;
+      this.#trackedUrls.clear();
+    }
+    if (this.#scrollTimeout) {
+      window.clearTimeout(this.#scrollTimeout);
+    }
+    this.#scrollTimeout = window.setTimeout(() => {
+      const scrollDepth = this.calculateScrollDepth();
+      if (scrollDepth > this.#maxScroll) {
+        this.#maxScroll = scrollDepth;
+        this.checkAndTrackScrollDepth(scrollDepth);
+      }
+    }, 100);
+  }
+  setupScrollTracking() {
+    window.addEventListener("scroll", this.#scrollHandler);
+    window.addEventListener("resize", this.#resizeHandler);
+  }
+  calculateScrollDepth() {
+    const windowHeight = window.innerHeight;
+    const documentHeight = Math.max(document.documentElement.scrollHeight, document.documentElement.offsetHeight, document.documentElement.clientHeight);
+    const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+    return Math.round((scrollTop + windowHeight) / documentHeight * 100);
+  }
+  checkAndTrackScrollDepth(currentDepth) {
+    const url = window.location.href;
+    if (currentDepth > 50 && !this.#trackedUrls.has(url)) {
+      this.#trackedUrls.add(url);
+      this.trackCustomEvent("scroll");
+    }
+  }
+  extractClickLabel(element) {
+    const ariaLabel = element.getAttribute("aria-label");
+    if (ariaLabel)
+      return `${ariaLabel}`;
+    if (element instanceof HTMLButtonElement || element instanceof HTMLAnchorElement) {
+      const text = element.textContent?.trim();
+      if (text)
+        return `${text}`;
+    }
+    if (element instanceof HTMLInputElement) {
+      if (element.type === "submit" && element.value) {
+        return `${element.value}`;
+      }
+      if (element.type === "checkbox") {
+        const label = this.findInputLabel(element);
+        const action = element.checked ? "Checked" : "Unchecked";
+        return label ? `${action} ${label}` : null;
+      }
+    }
+    const labelElement = element.closest("label");
+    if (labelElement) {
+      const text = labelElement.textContent?.trim();
+      if (text)
+        return `${text}`;
+    }
+    return null;
+  }
+  findInputLabel(input) {
+    const ariaLabel = input.getAttribute("aria-label");
+    if (ariaLabel)
+      return ariaLabel;
+    if (input.id) {
+      const label = document.querySelector(`label[for="${input.id}"]`);
+      if (label && label.textContent)
+        return label.textContent.trim();
+    }
+    const parentLabel = input.closest("label");
+    if (parentLabel && parentLabel.textContent) {
+      const labelText = parentLabel.textContent.trim();
+      return labelText.replace(input.value, "").trim();
+    }
+    return null;
+  }
+  trackPageView() {
+    const event = {
+      name: "page_view",
+      url: window.location.href,
+      referrer: document.referrer,
+      title: document.title,
+      timestamp: new Date().toISOString()
+    };
+    this.#session.track(event);
+  }
+  trackCustomEvent(name, properties = {}, options = {
+    immediate: false
+  }) {
+    const event = {
+      name,
+      url: window.location.href,
+      referrer: document.referrer,
+      title: document.title,
+      properties,
+      timestamp: new Date().toISOString()
+    };
+    if (options.immediate) {
+      this.#session.publish([event]);
+    } else {
+      this.#session.track(event);
+    }
+  }
+  trackPurchase(params) {
+    const event = {
+      name: "purchase",
+      url: window.location.href,
+      referrer: document.referrer,
+      title: document.title,
+      productId: params.productId,
+      price: params.price,
+      currency: params.currency,
+      properties: {
+        ...params.properties
+      },
+      timestamp: new Date().toISOString()
+    };
+    this.#session.track(event);
+  }
+  setupFormTracking() {
+    document.addEventListener("focus", this.#inputFocusHandler, true);
+    document.addEventListener("blur", this.#inputBlurHandler, true);
+    document.addEventListener("change", this.#formChangeHandler, true);
+    document.addEventListener("submit", this.#formSubmitHandler, true);
+  }
+  handleInputFocus(event) {
+    const element = event.target;
+    if (!element || !(element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement)) {
+      return;
+    }
+    if (element instanceof HTMLInputElement && element.type === "password") {
+      return;
+    }
+    this.#inputInitialValues.set(element, this.getElementValue(element));
+    const form = element.closest("form");
+    if (form && !this.#formStartTimes.has(form)) {
+      this.#formStartTimes.set(form, Date.now());
+    }
+  }
+  getElementValue(element) {
+    if (element instanceof HTMLSelectElement) {
+      return element.value;
+    }
+    if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+      return element.value;
+    }
+    return "";
+  }
+  handleInputBlur(event) {
+    const element = event.target;
+    if (!element || !(element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement)) {
+      return;
+    }
+    if (element instanceof HTMLInputElement && element.type === "password") {
+      return;
+    }
+    const initialValue = this.#inputInitialValues.get(element) || "";
+    const currentValue = this.getElementValue(element);
+    if (currentValue !== initialValue && currentValue.trim() !== "") {
+      const inputType = element instanceof HTMLSelectElement ? "select" : element.type;
+      const label = this.findFormElementLabel(element) || this.getInputIdentifier(element);
+      if (!label)
+        return;
+      this.trackCustomEvent("input_fill", {
+        input_type: inputType,
+        label,
+        form_name: this.getFormName(element)
+      });
+    }
+    this.#inputInitialValues.delete(element);
+  }
+  getFormName(element) {
+    const form = element.closest("form");
+    if (!form)
+      return;
+    return form.getAttribute("name") || form.getAttribute("id") || form.getAttribute("aria-label") || undefined;
+  }
+  getInputIdentifier(element) {
+    return element.getAttribute("name") || element.getAttribute("id") || element.getAttribute("placeholder") || null;
+  }
+  findFormElementLabel(element) {
+    const ariaLabel = element.getAttribute("aria-label");
+    if (ariaLabel)
+      return ariaLabel;
+    if (element.id) {
+      const label = document.querySelector(`label[for="${element.id}"]`);
+      if (label && label.textContent)
+        return label.textContent.trim();
+    }
+    const parentLabel = element.closest("label");
+    if (parentLabel && parentLabel.textContent) {
+      const labelText = parentLabel.textContent.trim();
+      const value = element instanceof HTMLSelectElement ? element.selectedOptions[0]?.text : element.value;
+      return value ? labelText.replace(value, "").trim() : labelText;
+    }
+    return null;
+  }
+  handleFormChange(event) {
+    const element = event.target;
+    if (!element || !(element instanceof HTMLSelectElement || element instanceof HTMLInputElement)) {
+      return;
+    }
+    if (element instanceof HTMLSelectElement) {
+      this.trackSelectChange(element);
+    } else if (element instanceof HTMLInputElement) {
+      if (element.type === "radio") {
+        this.trackRadioChange(element);
+      } else if (element.type === "checkbox") {
+        this.trackCheckboxChange(element);
+      } else if (element.type === "range") {
+        this.trackRangeChange(element);
+      }
+    }
+  }
+  trackSelectChange(element) {
+    const label = this.findFormElementLabel(element) || this.getInputIdentifier(element);
+    if (!label)
+      return;
+    const selectedOption = element.selectedOptions[0];
+    this.trackCustomEvent("input_select", {
+      input_type: "select",
+      label,
+      option_label: selectedOption?.text || "",
+      form_name: this.getFormName(element)
+    });
+  }
+  trackRadioChange(element) {
+    const label = this.findFormElementLabel(element) || this.getInputIdentifier(element);
+    if (!label)
+      return;
+    const groupName = element.name || label;
+    this.trackCustomEvent("input_radio", {
+      input_type: "radio",
+      group: groupName,
+      label,
+      form_name: this.getFormName(element)
+    });
+  }
+  trackCheckboxChange(element) {
+    const label = this.findFormElementLabel(element) || this.getInputIdentifier(element);
+    if (!label)
+      return;
+    this.trackCustomEvent("input_checkbox", {
+      input_type: "checkbox",
+      label,
+      checked: element.checked,
+      form_name: this.getFormName(element)
+    });
+  }
+  trackRangeChange(element) {
+    const label = this.findFormElementLabel(element) || this.getInputIdentifier(element);
+    if (!label)
+      return;
+    this.trackCustomEvent("input_range", {
+      input_type: "range",
+      label,
+      form_name: this.getFormName(element)
+    });
+  }
+  handleFormSubmit(event) {
+    const form = event.target;
+    if (!form || !(form instanceof HTMLFormElement))
+      return;
+    const startTime = this.#formStartTimes.get(form) || Date.now();
+    const timeToComplete = Date.now() - startTime;
+    const formName = this.getFormName(form) || "unknown";
+    this.trackCustomEvent("form_submit", {
+      form_name: formName,
+      time_to_complete: timeToComplete
+    });
+    this.#formStartTimes.delete(form);
+  }
+  setupVideoTracking() {
+    document.addEventListener("play", this.#videoPlayHandler, true);
+    document.addEventListener("pause", this.#videoPauseHandler, true);
+    document.addEventListener("ended", this.#videoEndHandler, true);
+  }
+  getVideoMetadata(video) {
+    return {
+      duration: Math.round(video.duration),
+      current_time: Math.round(video.currentTime),
+      src: video.currentSrc || video.src || undefined,
+      title: video.title || undefined,
+      video_id: video.id || undefined
+    };
+  }
+  handleVideoPlay(event) {
+    const video = event.target;
+    if (!video || !(video instanceof HTMLVideoElement))
+      return;
+    this.#videoStartTimes.set(video, Date.now());
+    this.trackCustomEvent("video_play", this.getVideoMetadata(video));
+  }
+  handleVideoPause(event) {
+    const video = event.target;
+    if (!video || !(video instanceof HTMLVideoElement))
+      return;
+    const startTime = this.#videoStartTimes.get(video);
+    const metadata = this.getVideoMetadata(video);
+    if (startTime) {
+      metadata.watch_time = Math.round((Date.now() - startTime) / 1000);
+      this.#videoStartTimes.delete(video);
+    }
+    this.trackCustomEvent("video_pause", metadata);
+  }
+  handleVideoEnd(event) {
+    const video = event.target;
+    if (!video || !(video instanceof HTMLVideoElement))
+      return;
+    const startTime = this.#videoStartTimes.get(video);
+    const metadata = this.getVideoMetadata(video);
+    if (startTime) {
+      metadata.watch_time = Math.round((Date.now() - startTime) / 1000);
+      this.#videoStartTimes.delete(video);
+    }
+    this.trackCustomEvent("video_complete", metadata);
+  }
+  setupPageTimeTracking() {
+    document.addEventListener("visibilitychange", this.#visibilityChangeHandler);
+    window.addEventListener("beforeunload", this.#beforeUnloadHandler);
+  }
+  handleVisibilityChange() {
+    const now = Date.now();
+    const wasVisible = this.#isPageVisible;
+    this.#isPageVisible = !document.hidden;
+    if (wasVisible) {
+      this.#pageVisibleTime += now - this.#lastVisibilityChange;
+    }
+    this.#lastVisibilityChange = now;
+    this.trackCustomEvent("page_visibility", {
+      visible: this.#isPageVisible,
+      total_time: Math.round((now - this.#pageStartTime) / 1000),
+      visible_time: Math.round(this.#pageVisibleTime / 1000)
+    });
+  }
+  handleBeforeUnload() {
+    const now = Date.now();
+    if (this.#isPageVisible) {
+      this.#pageVisibleTime += now - this.#lastVisibilityChange;
+    }
+    this.trackCustomEvent("page_exit", {
+      total_time: Math.round((now - this.#pageStartTime) / 1000),
+      visible_time: Math.round(this.#pageVisibleTime / 1000)
+    }, {
+      immediate: true
+    });
+  }
+  setupInactivityTracking() {
+    ["mousemove", "mousedown", "keydown", "touchstart", "scroll"].forEach((eventType) => {
+      document.addEventListener(eventType, this.#activityHandler, true);
+    });
+    this.checkInactivity();
+  }
+  handleUserActivity() {
+    this.#lastActivityTime = Date.now();
+    if (this.#isUserInactive && this.#inactivityStartTime) {
+      this.#isUserInactive = false;
+      this.trackCustomEvent("user_active", {
+        inactive_duration: Math.round((Date.now() - this.#inactivityStartTime) / 1000),
+        url: window.location.href,
+        title: document.title
+      });
+      this.#inactivityStartTime = null;
+    }
+    this.checkInactivity();
+  }
+  checkInactivity() {
+    if (this.#inactivityTimeout) {
+      window.clearTimeout(this.#inactivityTimeout);
+    }
+    this.#inactivityTimeout = window.setTimeout(() => {
+      const now = Date.now();
+      const inactiveDuration = now - this.#lastActivityTime;
+      if (inactiveDuration >= this.#inactivityThreshold && !this.#isUserInactive) {
+        this.#isUserInactive = true;
+        this.#inactivityStartTime = now;
+        this.trackCustomEvent("user_inactive");
+      }
+    }, this.#inactivityThreshold);
+  }
+  installErrorHandler() {
+    if (this.#errorHandlerInstalled || typeof window === "undefined") {
+      return;
+    }
+    window.addEventListener("error", this.#errorHandler);
+    window.addEventListener("unhandledrejection", this.#rejectionHandler);
+    this.#errorHandlerInstalled = true;
+  }
+  uninstallErrorHandler() {
+    if (!this.#errorHandlerInstalled || typeof window === "undefined") {
+      return;
+    }
+    window.removeEventListener("error", this.#errorHandler);
+    window.removeEventListener("unhandledrejection", this.#rejectionHandler);
+    this.#errorHandlerInstalled = false;
+  }
+  isErrorHandlerInstalled() {
+    return this.#errorHandlerInstalled;
+  }
+  handleError(event) {
+    if (event instanceof ErrorEvent) {
+      this.trackError(new Error(event.message), {
+        filename: event.filename,
+        lineno: event.lineno,
+        colno: event.colno,
+        source: "window.onerror"
+      });
+    }
+  }
+  handleRejection(event) {
+    const error = event.reason instanceof Error ? event.reason : new Error(String(event.reason || "Unhandled Promise rejection"));
+    this.trackError(error, { source: "unhandledrejection" });
+  }
+  trackError(error, properties = {}, options = {
+    immediate: false
+  }) {
+    const {
+      filename,
+      lineno,
+      colno,
+      source,
+      url,
+      referrer,
+      userAgent,
+      ...cleanProperties
+    } = properties;
+    const event = {
+      name: "error",
+      message: error.message,
+      stack: error.stack,
+      source: source || "client",
+      lineno,
+      colno,
+      filename,
+      properties: cleanProperties,
+      timestamp: new Date().toISOString(),
+      url: url || window.location.href,
+      referrer: referrer || document.referrer,
+      title: document.title
+    };
+    if (options.immediate) {
+      this.#session.publish([event]);
+    } else {
+      this.#session.track(event);
+    }
+  }
+}
+
+// ../core/src/browser/libs/LocalStorage.ts
+class LocalStorage {
+  namespace;
+  constructor({ namespace }) {
+    this.namespace = namespace;
+  }
+  getItem(key) {
+    const item = localStorage.getItem(`${this.namespace}.${key}`) || "";
+    try {
+      return JSON.parse(item);
+    } catch (_) {
+      return null;
+    }
+  }
+  setItem(key, value) {
+    localStorage.setItem(`${this.namespace}.${key}`, JSON.stringify(value));
+  }
+  removeItem(key) {
+    localStorage.removeItem(`${this.namespace}.${key}`);
+  }
+}
+// ../core/src/browser/libs/memory.ts
+var memory = new LocalStorage({ namespace: "userpath" });
+// ../core/src/browser/libs/cookie.ts
+function setCookie(name, value, options = {}) {
+  const { days = 7, path = "/", domain, secure, sameSite = "strict" } = options;
+  const expires = days ? new Date(Date.now() + days * 86400000).toUTCString() : "";
+  let cookieString = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (expires)
+    cookieString += `; expires=${expires}`;
+  if (path)
+    cookieString += `; path=${path}`;
+  if (domain)
+    cookieString += `; domain=${domain}`;
+  if (secure)
+    cookieString += "; secure";
+  if (sameSite)
+    cookieString += `; samesite=${sameSite}`;
+  document.cookie = cookieString;
+}
+function getCookie(name) {
+  const nameEQ = encodeURIComponent(name) + "=";
+  const cookies = document.cookie.split(";");
+  for (let i = 0;i < cookies.length; i++) {
+    let cookie = cookies[i];
+    while (cookie.charAt(0) === " ") {
+      cookie = cookie.substring(1, cookie.length);
+    }
+    if (cookie.indexOf(nameEQ) === 0) {
+      return decodeURIComponent(cookie.substring(nameEQ.length, cookie.length));
+    }
+  }
+  return null;
+}
+// src/base/session.ts
+class SessionClient {
+  #api;
+  #queue = [];
+  #events = null;
+  #userId;
+  #appId;
+  #currentUrl = "";
+  #flushInterval = null;
+  #batchFlushTimeout = null;
+  #flushIntervalMs = 5000;
+  constructor(api, config) {
+    this.#api = api;
+    this.#userId = config?.userId;
+    this.#appId = config?.appId || "";
+    this.#flushIntervalMs = config?.flushIntervalMs || DEFAULT_CONFIG.flushIntervalMs || 5000;
+  }
+  init(events) {
+    this.#events = events;
+    this.setup();
+  }
+  destroy() {
+    if (this.#flushInterval) {
+      window.clearInterval(this.#flushInterval);
+    }
+    if (this.#batchFlushTimeout) {
+      window.clearTimeout(this.#batchFlushTimeout);
+    }
+    if (this.#queue.length > 0) {
+      this.flush();
+    }
+  }
+  setup() {
+    if (typeof window === "undefined")
+      return;
+    this.#currentUrl = window.location.href;
+    this.#events.trackPageView();
+    this.setupHistoryChange();
+    this.#flushInterval = window.setInterval(() => this.flush(), this.#flushIntervalMs);
+  }
+  setupHistoryChange() {
+    if (!this.#events)
+      return;
+    const originalPushState = history.pushState;
+    const originalReplaceState = history.replaceState;
+    history.pushState = (...args) => {
+      originalPushState.apply(history, args);
+      this.trackPageViewIfUrlChanged();
+    };
+    history.replaceState = (...args) => {
+      originalReplaceState.apply(history, args);
+      this.trackPageViewIfUrlChanged();
+    };
+    window.addEventListener("popstate", () => {
+      this.trackPageViewIfUrlChanged();
+    });
+  }
+  trackPageViewIfUrlChanged() {
+    const newUrl = window.location.href;
+    if (newUrl !== this.#currentUrl) {
+      this.#currentUrl = newUrl;
+      this.#events.trackPageView();
+    }
+  }
+  getUserId() {
+    return this.#userId;
+  }
+  setUserId(userId) {
+    this.#userId = userId;
+  }
+  getAppId() {
+    return this.#appId;
+  }
+  setAppId(appId) {
+    this.#appId = appId;
+  }
+  track(event) {
+    this.#queue.push(event);
+    if (this.#queue.length >= 20) {
+      this.flush();
+      return;
+    }
+    if (!this.#batchFlushTimeout) {
+      this.#batchFlushTimeout = window.setTimeout(() => {
+        this.flush();
+        this.#batchFlushTimeout = null;
+      }, this.#flushIntervalMs);
+    }
+  }
+  async identify(identity) {
+    this.setUserId(identity.id);
+    await fetch(this.#api.buildUrl("identify"), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-UserPath-App": this.#appId,
+        "X-UserPath-Session": this.getSessionId(),
+        ...this.#userId && { "X-UserPath-User": this.#userId }
+      },
+      body: JSON.stringify(identity),
+      keepalive: true
+    });
+  }
+  deduplicateEvents(events) {
+    const seen = new Set;
+    return events.filter((event) => {
+      const key = `${event.name}-${event.timestamp}`;
+      if (seen.has(key)) {
+        return false;
+      }
+      seen.add(key);
+      return true;
+    });
+  }
+  flush() {
+    if (this.#queue.length === 0)
+      return;
+    if (this.#batchFlushTimeout) {
+      window.clearTimeout(this.#batchFlushTimeout);
+      this.#batchFlushTimeout = null;
+    }
+    const events = [...this.#queue];
+    this.#queue = [];
+    const uniqueEvents = this.deduplicateEvents(events);
+    this.publish(uniqueEvents).catch((error) => {
+      this.#queue = [...uniqueEvents, ...this.#queue].slice(0, 100);
+      console.error("Error sending analytics data:", error);
+    });
+  }
+  async publish(events) {
+    return fetch(this.#api.buildUrl("log"), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-UserPath-App": this.#appId,
+        "X-UserPath-Session": this.getSessionId(),
+        ...this.#userId && { "X-UserPath-User": this.#userId }
+      },
+      body: JSON.stringify({
+        userAgent: navigator.userAgent,
+        screenWidth: window.screen.width,
+        screenHeight: window.screen.height,
+        language: navigator.language,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        events: events.map((event) => {
+          if (!event.timestamp) {
+            event.timestamp = new Date().toISOString();
+          }
+          return {
+            ...event,
+            name: event.name || event.type,
+            properties: event.properties || {}
+          };
+        })
+      }),
+      credentials: "include",
+      keepalive: true
+    });
+  }
+  getSessionId() {
+    let sessionId = getCookie("userpath.session_id");
+    if (!sessionId) {
+      sessionId = this.generateId();
+      setCookie("userpath.session_id", sessionId, { days: 365 });
+    }
+    return sessionId;
+  }
+  generateId() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+}
+
+// src/index.ts
+class UserPath {
+  #api;
+  #session;
+  #events;
+  #version = DEFAULT_CONFIG.version;
+  constructor(config2) {
+    this.#api = new ApiClient(config2);
+    this.#session = new SessionClient(this.#api, config2);
+    this.#events = new EventsClient(this.#session, config2);
+    this.#version = config2.version || this.#version;
+    this.#session.init(this.#events);
+    this.#session.setAppId(config2.appId);
+    const shouldTrackErrors = config2.autoTrack?.errors !== undefined ? config2.autoTrack.errors : true;
+    if (shouldTrackErrors) {
+      this.installErrorHandler();
+    }
+    console.debug(`UserPath v${package_default.version} initialized`);
+  }
+  getAppId() {
+    return this.#session.getAppId();
+  }
+  setAppId(appId) {
+    this.#session.setAppId(appId);
+  }
+  installErrorHandler() {
+    this.#events.installErrorHandler();
+  }
+  uninstallErrorHandler() {
+    this.#events.uninstallErrorHandler();
+  }
+  trackError(error, properties = {}) {
+    if (!this.#events.isErrorHandlerInstalled() && properties.source !== "manual") {
+      return;
+    }
+    this.#events.trackError(error, properties);
+  }
+  setUserId(userId) {
+    this.#session.setUserId(userId);
+  }
+  getUserId() {
+    return this.#session.getUserId();
+  }
+  async identify(identity2) {
+    await this.#session.identify(identity2);
+  }
+  track(eventType, params) {
+    if (eventType === "page_view") {
+      this.#events.trackPageView();
+    } else if (eventType === "event") {
+      this.#events.trackCustomEvent(params.name, params.properties || {});
+    } else if (eventType === "purchase") {
+      this.#events.trackPurchase({
+        productId: params.properties?.product_id || "",
+        price: params.price,
+        currency: params.currency,
+        properties: params.properties
+      });
+    }
+  }
+}
+export {
+  UserPath,
+  DEFAULT_CONFIG
+};