datafast 1.0.1

package/dist/web/index.js

@@ -0,0 +1,789 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// src/core/utils.ts
+function generateVisitorId() {
+  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 generateSessionId() {
+  return "sxxxxxxxx-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 isValidVisitorId(id) {
+  if (!id || typeof id !== "string" || id.length !== 36) return false;
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id);
+}
+function isValidSessionId(id) {
+  if (!id || typeof id !== "string" || id.length !== 37) return false;
+  return /^s[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id);
+}
+function buildScreenHref(platform, screenName) {
+  const normalizedName = screenName.replace(/^\/+/, "").trim();
+  return `datafast://${platform}/${normalizedName}`;
+}
+function buildUserAgent(sdkVersion, platform, osVersion, deviceModel) {
+  const os = platform === "ios" ? "iOS" : platform === "android" ? "Android" : "Web";
+  return `DataFast/${sdkVersion} (${os} ${osVersion}; ${deviceModel})`;
+}
+function isValidEventName(name) {
+  if (!name || typeof name !== "string") return false;
+  if (name.length === 0 || name.length > 64) return false;
+  return /^[a-z0-9_-]+$/.test(name.toLowerCase());
+}
+function sanitizeCustomProperties(properties) {
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) {
+    return {};
+  }
+  const sanitized = {};
+  const entries = Object.entries(properties);
+  if (entries.length > 10) {
+    console.warn("[DataFast] Maximum 10 custom properties allowed");
+    return null;
+  }
+  for (const [key, value] of entries) {
+    if (key === "eventName") continue;
+    if (!key || typeof key !== "string" || key.length > 64) {
+      console.warn(`[DataFast] Invalid property name: ${key}`);
+      return null;
+    }
+    if (!/^[a-z0-9_-]+$/i.test(key)) {
+      console.warn(`[DataFast] Property name must be alphanumeric with _ or -: ${key}`);
+      return null;
+    }
+    let stringValue = value == null ? "" : String(value);
+    if (stringValue.length > 255) {
+      stringValue = stringValue.substring(0, 255);
+    }
+    stringValue = stringValue.replace(/[<>'"&]/g, "").replace(/javascript:/gi, "").replace(/on\w+=/gi, "").trim();
+    sanitized[key.toLowerCase()] = stringValue;
+  }
+  return sanitized;
+}
+function generateEventId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+function isSessionExpired(sessionStartTime) {
+  const SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
+  return Date.now() - sessionStartTime > SESSION_TTL_MS;
+}
+function createLogger(debug) {
+  return {
+    log: (...args) => {
+      if (debug) console.log("[DataFast]", ...args);
+    },
+    warn: (...args) => {
+      if (debug) console.warn("[DataFast]", ...args);
+    },
+    error: (...args) => {
+      console.error("[DataFast]", ...args);
+    }
+  };
+}
+
+// src/core/queue.ts
+var QUEUE_STORAGE_KEY = "datafast_event_queue";
+var MAX_RETRIES = 3;
+var EventQueue = class {
+  constructor(options) {
+    this.queue = [];
+    this.flushTimer = null;
+    this.isFlushing = false;
+    this.storage = options.storage;
+    this.network = options.network;
+    this.apiUrl = options.apiUrl;
+    this.userAgent = options.userAgent;
+    this.flushInterval = options.flushInterval ?? 3e4;
+    this.maxQueueSize = options.maxQueueSize ?? 20;
+    this.onFlushError = options.onFlushError;
+  }
+  /**
+   * Initialize the queue - load persisted events from storage
+   */
+  async init() {
+    try {
+      const stored = await this.storage.getItem(QUEUE_STORAGE_KEY);
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        if (Array.isArray(parsed)) {
+          this.queue = parsed;
+        }
+      }
+    } catch {
+      this.queue = [];
+    }
+    this.startFlushTimer();
+    if (this.network?.onConnectionChange) {
+      this.network.onConnectionChange((isConnected) => {
+        if (isConnected) {
+          this.flush();
+        }
+      });
+    }
+  }
+  /**
+   * Add an event to the queue
+   */
+  async enqueue(payload) {
+    const event = {
+      id: generateEventId(),
+      payload,
+      timestamp: Date.now(),
+      retries: 0
+    };
+    this.queue.push(event);
+    await this.persistQueue();
+    if (this.queue.length >= this.maxQueueSize) {
+      this.flush();
+    }
+  }
+  /**
+   * Flush all queued events to the server
+   */
+  async flush() {
+    if (this.isFlushing || this.queue.length === 0) {
+      return;
+    }
+    if (this.network) {
+      const isConnected = await this.network.isConnected();
+      if (!isConnected) {
+        return;
+      }
+    }
+    this.isFlushing = true;
+    const eventsToProcess = [...this.queue];
+    for (const event of eventsToProcess) {
+      try {
+        await this.sendEvent(event.payload);
+        this.queue = this.queue.filter((e) => e.id !== event.id);
+      } catch (error) {
+        event.retries++;
+        if (event.retries >= MAX_RETRIES) {
+          this.queue = this.queue.filter((e) => e.id !== event.id);
+          if (this.onFlushError) {
+            this.onFlushError(error, event);
+          }
+        }
+      }
+    }
+    await this.persistQueue();
+    this.isFlushing = false;
+  }
+  /**
+   * Send a single event to the API
+   */
+  async sendEvent(payload) {
+    const response = await fetch(this.apiUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": this.userAgent
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+  }
+  /**
+   * Persist queue to storage
+   */
+  async persistQueue() {
+    try {
+      await this.storage.setItem(QUEUE_STORAGE_KEY, JSON.stringify(this.queue));
+    } catch {
+    }
+  }
+  /**
+   * Start the periodic flush timer
+   */
+  startFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.flushInterval);
+  }
+  /**
+   * Stop the flush timer and flush remaining events
+   */
+  async shutdown() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+  /**
+   * Get current queue size
+   */
+  get size() {
+    return this.queue.length;
+  }
+  /**
+   * Clear all queued events
+   */
+  async clear() {
+    this.queue = [];
+    await this.persistQueue();
+  }
+};
+
+// src/core/client.ts
+var SDK_VERSION = "1.0.0";
+var DEFAULT_API_URL = "https://datafa.st/api/events";
+var STORAGE_KEYS = {
+  VISITOR_ID: "datafast_visitor_id",
+  SESSION_ID: "datafast_session_id",
+  SESSION_START: "datafast_session_start",
+  IGNORE_TRACKING: "datafast_ignore"
+};
+var DataFastClient = class {
+  constructor() {
+    this.state = {
+      initialized: false,
+      visitorId: null,
+      sessionId: null,
+      sessionStartTime: null,
+      lastScreenName: null,
+      config: null,
+      deviceInfo: null
+    };
+    this.queue = null;
+    this.logger = createLogger(false);
+  }
+  /**
+   * Initialize the SDK with configuration
+   */
+  async init(config) {
+    if (this.state.initialized) {
+      this.logger.warn("SDK already initialized");
+      return;
+    }
+    if (!config.appId) {
+      throw new Error("[DataFast] appId is required");
+    }
+    if (!config.domain) {
+      throw new Error("[DataFast] domain is required");
+    }
+    if (!config.storage) {
+      throw new Error("[DataFast] storage adapter is required");
+    }
+    if (!config.platform) {
+      throw new Error("[DataFast] platform is required");
+    }
+    this.state.config = config;
+    this.logger = createLogger(config.debug ?? false);
+    const ignoreTracking = await config.storage.getItem(STORAGE_KEYS.IGNORE_TRACKING);
+    if (ignoreTracking === "true") {
+      this.logger.log("Tracking disabled via user opt-out");
+      return;
+    }
+    await this.initVisitorId();
+    await this.initSessionId();
+    const apiUrl = config.apiUrl ?? DEFAULT_API_URL;
+    const userAgent = buildUserAgent(
+      SDK_VERSION,
+      config.platform,
+      config.appVersion ?? "1.0.0",
+      "Unknown"
+    );
+    this.queue = new EventQueue({
+      storage: config.storage,
+      network: config.network,
+      apiUrl,
+      userAgent,
+      flushInterval: config.flushInterval,
+      maxQueueSize: config.maxQueueSize,
+      onFlushError: (error, event) => {
+        this.logger.error("Failed to send event:", error, event.payload.type);
+      }
+    });
+    await this.queue.init();
+    this.state.initialized = true;
+    this.logger.log("SDK initialized", { visitorId: this.state.visitorId, sessionId: this.state.sessionId });
+  }
+  /**
+   * Track a screen view (equivalent to pageview)
+   */
+  async trackScreen(screenName) {
+    if (!this.isReady()) return;
+    if (!screenName || typeof screenName !== "string") {
+      this.logger.warn("trackScreen requires a screen name");
+      return;
+    }
+    const config = this.state.config;
+    const referrer = this.state.lastScreenName ? buildScreenHref(config.platform, this.state.lastScreenName) : null;
+    const payload = this.buildBasePayload("pageview", screenName);
+    payload.referrer = referrer;
+    await this.queue.enqueue(payload);
+    this.state.lastScreenName = screenName;
+    this.logger.log("Screen tracked:", screenName);
+  }
+  /**
+   * Track a custom event
+   */
+  async track(eventName, properties) {
+    if (!this.isReady()) return;
+    if (!isValidEventName(eventName)) {
+      this.logger.warn(
+        "Invalid event name. Use lowercase alphanumeric with _ or -, max 64 chars:",
+        eventName
+      );
+      return;
+    }
+    const sanitized = sanitizeCustomProperties(properties ?? {});
+    if (sanitized === null) {
+      this.logger.warn("Custom properties validation failed");
+      return;
+    }
+    const screenName = this.state.lastScreenName ?? "Unknown";
+    const payload = this.buildBasePayload("custom", screenName);
+    payload.extraData = {
+      eventName: eventName.toLowerCase(),
+      ...sanitized
+    };
+    await this.queue.enqueue(payload);
+    this.logger.log("Event tracked:", eventName, sanitized);
+  }
+  /**
+   * Identify a user
+   */
+  async identify(userId, properties) {
+    if (!this.isReady()) return;
+    if (!userId || typeof userId !== "string") {
+      this.logger.warn("identify requires a user_id");
+      return;
+    }
+    const screenName = this.state.lastScreenName ?? "Unknown";
+    const payload = this.buildBasePayload("identify", screenName);
+    payload.extraData = {
+      user_id: userId,
+      name: properties?.name ?? "",
+      image: properties?.image ?? "",
+      ...properties
+    };
+    await this.queue.enqueue(payload);
+    this.logger.log("User identified:", userId);
+  }
+  /**
+   * Track a payment event
+   */
+  async trackPayment(data) {
+    if (!this.isReady()) return;
+    if (!data.email || typeof data.email !== "string") {
+      this.logger.warn("trackPayment requires an email");
+      return;
+    }
+    const screenName = this.state.lastScreenName ?? "Unknown";
+    const payload = this.buildBasePayload("payment", screenName);
+    payload.extraData = {
+      email: data.email,
+      ...data.amount !== void 0 && { amount: data.amount },
+      ...data.currency && { currency: data.currency }
+    };
+    await this.queue.enqueue(payload);
+    this.logger.log("Payment tracked:", data.email);
+  }
+  /**
+   * Track an external link click
+   */
+  async trackExternalLink(url, text) {
+    if (!this.isReady()) return;
+    if (!url || typeof url !== "string") {
+      this.logger.warn("trackExternalLink requires a URL");
+      return;
+    }
+    const screenName = this.state.lastScreenName ?? "Unknown";
+    const payload = this.buildBasePayload("external_link", screenName);
+    payload.extraData = {
+      url,
+      ...text && { text }
+    };
+    await this.queue.enqueue(payload);
+    this.logger.log("External link tracked:", url);
+  }
+  /**
+   * Flush all queued events immediately
+   */
+  async flush() {
+    if (this.queue) {
+      await this.queue.flush();
+    }
+  }
+  /**
+   * Reset the session (start a new session)
+   */
+  async resetSession() {
+    if (!this.state.config) return;
+    const newSessionId = generateSessionId();
+    const now = Date.now();
+    this.state.sessionId = newSessionId;
+    this.state.sessionStartTime = now;
+    this.state.lastScreenName = null;
+    await this.state.config.storage.setItem(STORAGE_KEYS.SESSION_ID, newSessionId);
+    await this.state.config.storage.setItem(STORAGE_KEYS.SESSION_START, now.toString());
+    this.logger.log("Session reset:", newSessionId);
+  }
+  /**
+   * Reset the visitor (new anonymous user)
+   */
+  async reset() {
+    if (!this.state.config) return;
+    const newVisitorId = generateVisitorId();
+    const newSessionId = generateSessionId();
+    const now = Date.now();
+    this.state.visitorId = newVisitorId;
+    this.state.sessionId = newSessionId;
+    this.state.sessionStartTime = now;
+    this.state.lastScreenName = null;
+    await this.state.config.storage.setItem(STORAGE_KEYS.VISITOR_ID, newVisitorId);
+    await this.state.config.storage.setItem(STORAGE_KEYS.SESSION_ID, newSessionId);
+    await this.state.config.storage.setItem(STORAGE_KEYS.SESSION_START, now.toString());
+    if (this.queue) {
+      await this.queue.clear();
+    }
+    this.logger.log("Visitor reset:", newVisitorId);
+  }
+  /**
+   * Opt out of tracking
+   */
+  async optOut() {
+    if (!this.state.config) return;
+    await this.state.config.storage.setItem(STORAGE_KEYS.IGNORE_TRACKING, "true");
+    this.state.initialized = false;
+    if (this.queue) {
+      await this.queue.clear();
+      await this.queue.shutdown();
+    }
+    this.logger.log("User opted out of tracking");
+  }
+  /**
+   * Opt back into tracking
+   */
+  async optIn() {
+    if (!this.state.config) return;
+    await this.state.config.storage.removeItem(STORAGE_KEYS.IGNORE_TRACKING);
+    this.logger.log("User opted back into tracking. Call init() to restart.");
+  }
+  /**
+   * Set device info (call this when device info becomes available)
+   */
+  setDeviceInfo(info) {
+    this.state.deviceInfo = {
+      platform: info.platform ?? this.state.config?.platform ?? "ios",
+      osVersion: info.osVersion ?? "0.0",
+      deviceModel: info.deviceModel ?? "Unknown",
+      appVersion: info.appVersion ?? this.state.config?.appVersion ?? "1.0.0",
+      screenWidth: info.screenWidth ?? 0,
+      screenHeight: info.screenHeight ?? 0,
+      viewport: info.viewport ?? { width: 0, height: 0 },
+      language: info.language ?? "en",
+      timezone: info.timezone ?? "UTC"
+    };
+  }
+  /**
+   * Get current visitor ID
+   */
+  getVisitorId() {
+    return this.state.visitorId;
+  }
+  /**
+   * Get current session ID
+   */
+  getSessionId() {
+    return this.state.sessionId;
+  }
+  /**
+   * Check if SDK is initialized and ready
+   */
+  isInitialized() {
+    return this.state.initialized;
+  }
+  /**
+   * Shutdown the SDK
+   */
+  async shutdown() {
+    if (this.queue) {
+      await this.queue.shutdown();
+    }
+    this.state.initialized = false;
+  }
+  // Private methods
+  isReady() {
+    if (!this.state.initialized) {
+      this.logger.warn("SDK not initialized. Call init() first.");
+      return false;
+    }
+    return true;
+  }
+  async initVisitorId() {
+    const config = this.state.config;
+    let visitorId = await config.storage.getItem(STORAGE_KEYS.VISITOR_ID);
+    if (!visitorId || !isValidVisitorId(visitorId)) {
+      visitorId = generateVisitorId();
+      await config.storage.setItem(STORAGE_KEYS.VISITOR_ID, visitorId);
+    }
+    this.state.visitorId = visitorId;
+  }
+  async initSessionId() {
+    const config = this.state.config;
+    let sessionId = await config.storage.getItem(STORAGE_KEYS.SESSION_ID);
+    const sessionStartStr = await config.storage.getItem(STORAGE_KEYS.SESSION_START);
+    const sessionStart = sessionStartStr ? parseInt(sessionStartStr, 10) : 0;
+    if (!sessionId || !isValidSessionId(sessionId) || isSessionExpired(sessionStart)) {
+      sessionId = generateSessionId();
+      const now = Date.now();
+      await config.storage.setItem(STORAGE_KEYS.SESSION_ID, sessionId);
+      await config.storage.setItem(STORAGE_KEYS.SESSION_START, now.toString());
+      this.state.sessionStartTime = now;
+    } else {
+      this.state.sessionStartTime = sessionStart;
+    }
+    this.state.sessionId = sessionId;
+  }
+  buildBasePayload(type, screenName) {
+    const config = this.state.config;
+    const deviceInfo = this.state.deviceInfo;
+    return {
+      websiteId: config.appId,
+      domain: config.domain,
+      visitorId: this.state.visitorId,
+      sessionId: this.state.sessionId,
+      href: buildScreenHref(config.platform, screenName),
+      referrer: null,
+      type,
+      viewport: deviceInfo?.viewport ?? { width: 0, height: 0 },
+      language: deviceInfo?.language ?? "en",
+      timezone: deviceInfo?.timezone ?? "UTC",
+      screenWidth: deviceInfo?.screenWidth ?? 0,
+      screenHeight: deviceInfo?.screenHeight ?? 0
+    };
+  }
+};
+var instance = null;
+function getDataFastClient() {
+  if (!instance) {
+    instance = new DataFastClient();
+  }
+  return instance;
+}
+function createDataFastClient() {
+  return new DataFastClient();
+}
+
+// src/web/storage.ts
+function createLocalStorageAdapter() {
+  return {
+    async getItem(key) {
+      try {
+        return localStorage.getItem(key);
+      } catch (error) {
+        console.warn("[DataFast] localStorage.getItem failed:", error);
+        return null;
+      }
+    },
+    async setItem(key, value) {
+      try {
+        localStorage.setItem(key, value);
+      } catch (error) {
+        console.warn("[DataFast] localStorage.setItem failed:", error);
+      }
+    },
+    async removeItem(key) {
+      try {
+        localStorage.removeItem(key);
+      } catch (error) {
+        console.warn("[DataFast] localStorage.removeItem failed:", error);
+      }
+    }
+  };
+}
+function createMemoryStorageAdapter() {
+  const storage = /* @__PURE__ */ new Map();
+  return {
+    async getItem(key) {
+      return storage.get(key) ?? null;
+    },
+    async setItem(key, value) {
+      storage.set(key, value);
+    },
+    async removeItem(key) {
+      storage.delete(key);
+    }
+  };
+}
+
+// src/web/network.ts
+function createFetchNetworkAdapter() {
+  return {
+    async isConnected() {
+      return true;
+    },
+    onConnectionChange(callback) {
+      const handleOnline = () => callback(true);
+      const handleOffline = () => callback(false);
+      window.addEventListener("online", handleOnline);
+      window.addEventListener("offline", handleOffline);
+      return () => {
+        window.removeEventListener("online", handleOnline);
+        window.removeEventListener("offline", handleOffline);
+      };
+    }
+  };
+}
+
+// src/web/device.ts
+function getDeviceInfo() {
+  const getViewport = () => {
+    if (typeof window === "undefined") return { width: 0, height: 0 };
+    return {
+      width: window.innerWidth || 0,
+      height: window.innerHeight || 0
+    };
+  };
+  const getScreenSize = () => {
+    if (typeof window === "undefined" || !window.screen) return { width: 0, height: 0 };
+    return {
+      width: window.screen.width || 0,
+      height: window.screen.height || 0
+    };
+  };
+  const getLanguage = () => {
+    if (typeof navigator === "undefined") return "en";
+    return navigator.language || "en";
+  };
+  const getTimezone = () => {
+    try {
+      return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+    } catch {
+      return "UTC";
+    }
+  };
+  const getUserAgent = () => {
+    if (typeof navigator === "undefined") return "Unknown";
+    return navigator.userAgent || "Unknown";
+  };
+  const viewport = getViewport();
+  const screen = getScreenSize();
+  return {
+    platform: "web",
+    osVersion: getUserAgent(),
+    deviceModel: "Browser",
+    appVersion: "1.0.0",
+    screenWidth: screen.width,
+    screenHeight: screen.height,
+    viewport,
+    language: getLanguage(),
+    timezone: getTimezone()
+  };
+}
+function onViewportChange(callback) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const handleResize = () => {
+    callback({
+      width: window.innerWidth || 0,
+      height: window.innerHeight || 0
+    });
+  };
+  window.addEventListener("resize", handleResize);
+  return () => {
+    window.removeEventListener("resize", handleResize);
+  };
+}
+
+// src/web/index.ts
+async function initDataFast(config) {
+  const client = getDataFastClient();
+  let storage;
+  try {
+    localStorage.setItem("__datafast_test__", "test");
+    localStorage.removeItem("__datafast_test__");
+    storage = createLocalStorageAdapter();
+  } catch {
+    console.warn("[DataFast] localStorage not available, using in-memory storage");
+    storage = createMemoryStorageAdapter();
+  }
+  const network = createFetchNetworkAdapter();
+  const deviceInfo = getDeviceInfo();
+  const domain = config.domain ?? (typeof window !== "undefined" ? window.location.hostname : "unknown");
+  await client.init({
+    appId: config.websiteId,
+    domain,
+    storage,
+    network,
+    platform: "web",
+    apiUrl: config.apiUrl,
+    debug: config.debug,
+    flushInterval: config.flushInterval ?? 5e3,
+    maxQueueSize: config.maxQueueSize ?? 10
+  });
+  client.setDeviceInfo(deviceInfo);
+  onViewportChange((viewport) => {
+    client.setDeviceInfo({
+      ...deviceInfo,
+      viewport
+    });
+  });
+  const webClient = client;
+  webClient.trackPageview = async (path) => {
+    const pagePath = path ?? (typeof window !== "undefined" ? window.location.pathname : "/");
+    await client.trackScreen(pagePath);
+  };
+  return webClient;
+}
+async function createDataFastWithAdapters(config) {
+  const client = createDataFastClient();
+  await client.init(config);
+  const deviceInfo = getDeviceInfo();
+  client.setDeviceInfo(deviceInfo);
+  return client;
+}
+async function createDataFastWeb(config) {
+  return initDataFast(config);
+}
+var dataFastWeb = {
+  init: initDataFast,
+  createWeb: createDataFastWeb,
+  getClient: getDataFastClient,
+  createClient: createDataFastClient
+};
+var web_default = dataFastWeb;
+
+exports.DataFastClient = DataFastClient;
+exports.EventQueue = EventQueue;
+exports.buildScreenHref = buildScreenHref;
+exports.buildUserAgent = buildUserAgent;
+exports.createDataFastClient = createDataFastClient;
+exports.createDataFastWeb = createDataFastWeb;
+exports.createDataFastWithAdapters = createDataFastWithAdapters;
+exports.createFetchNetworkAdapter = createFetchNetworkAdapter;
+exports.createLocalStorageAdapter = createLocalStorageAdapter;
+exports.createLogger = createLogger;
+exports.createMemoryStorageAdapter = createMemoryStorageAdapter;
+exports.default = web_default;
+exports.generateEventId = generateEventId;
+exports.generateSessionId = generateSessionId;
+exports.generateVisitorId = generateVisitorId;
+exports.getDataFastClient = getDataFastClient;
+exports.getDeviceInfo = getDeviceInfo;
+exports.initDataFast = initDataFast;
+exports.isSessionExpired = isSessionExpired;
+exports.isValidEventName = isValidEventName;
+exports.isValidSessionId = isValidSessionId;
+exports.isValidVisitorId = isValidVisitorId;
+exports.onViewportChange = onViewportChange;
+exports.sanitizeCustomProperties = sanitizeCustomProperties;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map