plugeen 0.0.8 → 0.0.10

package/dist/index.cjs

@@ -1,5 +1,23 @@
 'use strict';
 
+// src/helpers/logger.ts
+function createLogger(debug) {
+  if (!debug) {
+    return { log: () => {
+    }, warn: () => {
+    }, error: () => {
+    } };
+  }
+  return {
+    // biome-ignore lint/suspicious/noConsole: Required
+    log: (...args) => console.log("[plugeen]", ...args),
+    // biome-ignore lint/suspicious/noConsole: Required
+    warn: (...args) => console.warn("[plugeen]", ...args),
+    // biome-ignore lint/suspicious/noConsole: Required
+    error: (...args) => console.error("[plugeen]", ...args)
+  };
+}
+
 // src/helpers/uuid.ts
 function generateUUID() {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
@@ -19,11 +37,12 @@ function generateUUID() {
   });
 }
 
-// src/storage.ts
+// src/storage/index.ts
 var IDENTITY_KEY = "plugeen_anon_id";
 var SESSION_KEY = "plugeen_session_id";
 var SESSION_TS_KEY = "plugeen_session_ts";
 var SESSION_TTL = 18e5;
+var memStore = {};
 function getOrCreateIdentityId() {
   try {
     let id = localStorage.getItem(IDENTITY_KEY);
@@ -33,13 +52,17 @@ function getOrCreateIdentityId() {
     }
     return id;
   } catch {
-    return `anon_${generateUUID()}`;
+    if (!memStore[IDENTITY_KEY]) {
+      memStore[IDENTITY_KEY] = `anon_${generateUUID()}`;
+    }
+    return memStore[IDENTITY_KEY];
   }
 }
 function setIdentityId(id) {
   try {
     localStorage.setItem(IDENTITY_KEY, id);
   } catch {
+    memStore[IDENTITY_KEY] = id;
   }
 }
 function getOrCreateSessionId() {
@@ -57,19 +80,28 @@ function getOrCreateSessionId() {
     sessionStorage.setItem(SESSION_TS_KEY, String(Date.now()));
     return id;
   } catch {
-    return `sess_${generateUUID()}`;
+    const existing = memStore[SESSION_KEY];
+    const ts = memStore[SESSION_TS_KEY];
+    if (existing && ts && Date.now() - parseInt(ts, 10) < SESSION_TTL) {
+      memStore[SESSION_TS_KEY] = String(Date.now());
+      return existing;
+    }
+    const id = `sess_${generateUUID()}`;
+    memStore[SESSION_KEY] = id;
+    memStore[SESSION_TS_KEY] = String(Date.now());
+    return id;
   }
 }
 
-// src/helpers/http-client.ts
+// src/http-client/index.ts
 var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var HttpClient = class {
-  constructor(apiUrl, apiKey, maxRetries = 3) {
-    this.apiUrl = apiUrl;
+  constructor(baseUrl, apiKey, maxRetries = 3) {
+    this.baseUrl = baseUrl;
     this.apiKey = apiKey;
     this.maxRetries = maxRetries;
   }
-  headers(method = "POST") {
+  headers(method) {
     const h = {
       Authorization: `Bearer ${this.apiKey}`,
       "x-identity-id": getOrCreateIdentityId(),
@@ -78,71 +110,58 @@ var HttpClient = class {
     if (method !== "GET") h["Content-Type"] = "application/json";
     return h;
   }
-  async post(path, body, attempt = 0) {
-    const url = `${this.apiUrl}${path}`;
+  async request(path, { attempt = 0, method, body, searchParams }) {
+    const sufix = searchParams ? `?${new URLSearchParams(searchParams).toString()}` : "";
+    const url = `${this.baseUrl}${path}${sufix}`;
     try {
       const res = await fetch(url, {
-        method: "POST",
-        headers: this.headers("POST"),
-        body: JSON.stringify(body),
-        keepalive: true,
-        credentials: "omit"
+        method,
+        headers: this.headers(method),
+        credentials: "omit",
+        body: body ? JSON.stringify(body) : void 0
       });
-      if (res.status === 401) return null;
+      if (res.status === 401 || res.status === 404) return [null, res.status];
       if ((res.status >= 500 || res.status === 429) && attempt < this.maxRetries) {
         const jitter = 0.85 + Math.random() * 0.3;
         await delay(500 * 2 ** attempt * jitter);
-        return this.post(path, body, attempt + 1);
+        return this.request(path, {
+          body,
+          attempt: attempt + 1,
+          method
+        });
       }
       if (res.status >= 200 && res.status < 300) {
         try {
           const json = await res.json();
-          return json?.data ?? null;
+          return [json.data, null];
         } catch {
-          return null;
+          return [null, "Failed to parse json"];
         }
       }
-      return null;
+      return [null, "Error"];
     } catch (err) {
       if (err instanceof TypeError && attempt < this.maxRetries) {
         const jitter = 0.85 + Math.random() * 0.3;
         await delay(500 * 2 ** attempt * jitter);
-        return this.post(path, body, attempt + 1);
+        return this.get(path, {
+          attempt: attempt + 1
+        });
       }
-      return null;
+      return [null, err];
     }
   }
-  async get(path, attempt = 0) {
-    const url = `${this.apiUrl}${path}`;
-    try {
-      const res = await fetch(url, {
-        method: "GET",
-        headers: this.headers("GET"),
-        credentials: "omit"
-      });
-      if (res.status === 401 || res.status === 404) return null;
-      if ((res.status >= 500 || res.status === 429) && attempt < this.maxRetries) {
-        const jitter = 0.85 + Math.random() * 0.3;
-        await delay(500 * 2 ** attempt * jitter);
-        return this.get(path, attempt + 1);
-      }
-      if (res.status >= 200 && res.status < 300) {
-        try {
-          const json = await res.json();
-          return json?.data ?? null;
-        } catch {
-          return null;
-        }
-      }
-      return null;
-    } catch (err) {
-      if (err instanceof TypeError && attempt < this.maxRetries) {
-        const jitter = 0.85 + Math.random() * 0.3;
-        await delay(500 * 2 ** attempt * jitter);
-        return this.get(path, attempt + 1);
-      }
-      return null;
-    }
+  async post(path, body, options) {
+    return this.request(path, {
+      attempt: options?.attempt ?? 0,
+      body,
+      method: "POST"
+    });
+  }
+  async get(path, options) {
+    return this.request(path, {
+      attempt: options?.attempt ?? 0,
+      method: "GET"
+    });
   }
   beacon(path, body) {
     if (typeof navigator === "undefined" || !navigator.sendBeacon) return false;
@@ -150,158 +169,23 @@ var HttpClient = class {
       const blob = new Blob([JSON.stringify(body)], {
         type: "application/json"
       });
-      return navigator.sendBeacon(`${this.apiUrl}${path}`, blob);
+      return navigator.sendBeacon(`${this.baseUrl}${path}`, blob);
     } catch {
       return false;
     }
   }
-  send(path, body, useBeacon = false) {
-    if (useBeacon) {
-      const sent = this.beacon(path, body);
-      if (sent) return;
-    }
-    void this.post(path, body);
-  }
 };
 
-// src/helpers/environment.ts
-function isLocalhost() {
-  if (typeof window === "undefined") return false;
-  const { hostname } = window.location;
-  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "0.0.0.0" || hostname.endsWith(".local");
-}
-function isOptedOut() {
-  try {
-    return localStorage.getItem("plugeen_opt_out") === "true";
-  } catch {
-    return false;
-  }
-}
-function detectBot() {
-  if (typeof navigator === "undefined") return false;
-  const ua = navigator.userAgent || "";
-  return Boolean(
-    navigator.webdriver || /HeadlessChrome/i.test(ua) || /PhantomJS/i.test(ua) || typeof window !== "undefined" && window._phantom
-  );
-}
-
-// src/helpers/should-skip.ts
-function matchesSkipPattern(patterns) {
-  if (patterns.length === 0 || typeof window === "undefined") return false;
-  const path = window.location.pathname;
-  for (const pattern of patterns) {
-    if (pattern === path) return true;
-    const star = pattern.indexOf("*");
-    if (star !== -1 && path.startsWith(pattern.slice(0, star))) return true;
-  }
-  return false;
-}
-function shouldSkip(options) {
-  if (options.disabled) return true;
-  if (isOptedOut()) return true;
-  if (detectBot()) return true;
-  if (!options.debug && isLocalhost()) return true;
-  if (matchesSkipPattern(options.skipPatterns)) return true;
-  if (options.samplingRate < 1 && Math.random() > options.samplingRate)
-    return true;
-  return false;
-}
-
-// src/modules/events.ts
-function createEventsModule(http, options) {
-  return {
-    create: async (name, data = {}) => {
-      if (shouldSkip(options)) return null;
-      return http.post("/api/events", { name, data, source: "api" });
-    }
-  };
-}
-
-// src/modules/experiments.ts
-function createExperimentsModule(http, options) {
-  return {
-    get: (id) => {
-      if (shouldSkip(options)) return Promise.resolve(null);
-      return http.get(
-        `/api/v1/experiments/${encodeURIComponent(id)}`
-      );
-    }
-  };
-}
-
-// src/modules/feature-flags.ts
-function createFeatureFlagsModule(http, options) {
-  return {
-    get: (key) => {
-      if (shouldSkip(options)) return Promise.resolve(null);
-      return http.get(
-        `/api/v1/feature-flags/${encodeURIComponent(key)}`
-      );
-    }
-  };
-}
-
-// src/modules/identities.ts
-function createIdentitiesModule(http, options) {
-  return {
-    set: async (distinctId, data = {}) => {
-      if (shouldSkip(options)) return null;
-      const result = await http.post("/api/identities", {
-        id: distinctId,
-        ...data
-      });
-      setIdentityId(distinctId);
-      return result;
-    }
-  };
-}
-
-// src/modules/logs.ts
-function createLogsModule(http, options) {
-  return {
-    send: (payload) => {
-      if (shouldSkip(options)) return Promise.resolve(null);
-      return http.post("/api/v1/logs", payload);
-    }
-  };
-}
-
-// src/modules/surveys.ts
-function createSurveysModule(http, options) {
-  return {
-    submit: (payload) => {
-      if (shouldSkip(options)) return Promise.resolve(null);
-      return http.post("/api/v1/surveys", payload);
-    }
-  };
-}
-
-// src/plugins/analytics.ts
-function initAnalyticsPlugin(plugeen, http) {
+// src/modules/client/analytics/index.ts
+function initAnalyticsModule(http, logger) {
   if (typeof window === "undefined") return;
+  logger.log("Analytics module started");
   let pageStartTime = Date.now();
-  let maxScrollDepth = 0;
-  let interactionCount = 0;
   let pageCount = 0;
   let currentUrl = window.location.href;
-  const updateScrollDepth = () => {
-    const scrollY = window.scrollY;
-    const { scrollHeight, clientHeight } = document.documentElement;
-    const available = scrollHeight - clientHeight;
-    if (available <= 0) return;
-    const depth = Math.min(100, Math.round(scrollY / available * 100));
-    if (depth > maxScrollDepth) maxScrollDepth = depth;
-  };
-  window.addEventListener("scroll", updateScrollDepth, { passive: true });
-  const countInteraction = () => {
-    interactionCount++;
-  };
-  for (const evt of ["mousedown", "keydown", "touchstart"]) {
-    window.addEventListener(evt, countInteraction, { passive: true });
-  }
   const trackPageView = () => {
     pageCount++;
-    const body = {
+    void http.post("/v1/analytics", {
       event: "page_view",
       url: window.location.href,
       title: document.title,
@@ -309,33 +193,31 @@ function initAnalyticsPlugin(plugeen, http) {
       referrer: document.referrer || void 0,
       screenWidth: window.innerWidth,
       screenHeight: window.innerHeight
-    };
-    void http.post("/api/v1/analytics", body);
+    });
   };
-  const buildPageExitData = () => ({
-    url: currentUrl,
-    time_on_page: Math.round((Date.now() - pageStartTime) / 1e3),
-    scroll_depth: maxScrollDepth,
-    interaction_count: interactionCount,
-    page_count: pageCount
-  });
   const trackPageExit = (useBeacon = false) => {
-    const data = buildPageExitData();
+    const data = {
+      event: "page_exit",
+      url: window.location.href,
+      title: document.title,
+      sessionId: getOrCreateSessionId(),
+      referrer: document.referrer || void 0,
+      screenWidth: window.innerWidth,
+      screenHeight: window.innerHeight,
+      metadata: {
+        timeOnPage: Math.round((Date.now() - pageStartTime) / 1e3),
+        pageCount
+      }
+    };
     if (useBeacon) {
-      http.send(
-        "/api/events",
-        { name: "page_exit", data, source: "api" },
-        true
-      );
+      http.beacon("/v1/analytics", data);
     } else {
-      void plugeen.events.create("page_exit", data);
+      void http.post("/v1/analytics", data);
     }
   };
   const onRouteChange = () => {
     if (window.location.href === currentUrl) return;
     trackPageExit();
-    maxScrollDepth = 0;
-    interactionCount = 0;
     pageStartTime = Date.now();
     currentUrl = window.location.href;
     trackPageView();
@@ -350,18 +232,15 @@ function initAnalyticsPlugin(plugeen, http) {
   patchHistoryMethod("pushState");
   patchHistoryMethod("replaceState");
   window.addEventListener("popstate", onRouteChange);
-  window.addEventListener("beforeunload", () => {
-    trackPageExit(true);
-  });
-  document.addEventListener("visibilitychange", () => {
-    if (document.visibilityState === "hidden") {
-      trackPageExit(true);
-    }
-  });
+  window.addEventListener("beforeunload", () => trackPageExit(true));
+  document.addEventListener(
+    "visibilitychange",
+    () => document.visibilityState === "hidden" && trackPageExit(true)
+  );
   trackPageView();
 }
 
-// src/plugins/errors.ts
+// src/modules/client/error/helpers.ts
 var EXTENSION_PREFIXES = [
   "chrome-extension://",
   "moz-extension://",
@@ -373,19 +252,24 @@ function isExtensionSource(str) {
   const lower = str.toLowerCase();
   return EXTENSION_PREFIXES.some((prefix) => lower.includes(prefix));
 }
-function initErrorsPlugin(plugeen) {
+
+// src/modules/client/error/index.ts
+function initErrorsModule(http, logger) {
   if (typeof window === "undefined") return;
+  logger.log("Errors module started");
   window.addEventListener("error", (event) => {
     if (isExtensionSource(event.filename) || isExtensionSource(event.error?.stack))
       return;
     if (event.error === null && event.message === "Script error.") return;
-    void plugeen.events.create("error", {
+    void http.post("/v1/logs", {
       message: event.message || "Unknown Error",
-      filename: event.filename,
-      lineno: event.lineno,
-      colno: event.colno,
-      stack: event.error?.stack,
-      error_type: event.error?.name || "Error"
+      level: "error",
+      url: window.location.href,
+      source: "client",
+      metadata: {
+        stack: event.error?.stack,
+        type: event.error?.name
+      }
     });
   });
   window.addEventListener(
@@ -404,21 +288,21 @@ function initErrorsPlugin(plugeen) {
       } else if (reason !== null && typeof reason === "object" && "message" in reason) {
         message = String(reason.message);
       }
-      void plugeen.events.create("error", {
+      void http.post("/v1/logs", {
         message,
-        stack,
-        error_type: "UnhandledRejection"
+        url: window.location.href,
+        source: "client",
+        level: "error",
+        metadata: {
+          stack,
+          type: "UnhandledRejection"
+        }
       });
     }
   );
 }
 
-// src/plugins/web-vitals/helpers.ts
-function getRating(value, thresholds) {
-  if (value > thresholds[1]) return "poor";
-  if (value > thresholds[0]) return "needs-improvement";
-  return "good";
-}
+// src/modules/client/web-vitals/helpers.ts
 function getActivationStart() {
   const nav = performance.getEntriesByType(
     "navigation"
@@ -450,14 +334,10 @@ function observeFCP(cb) {
   const reported = /* @__PURE__ */ new Set();
   observe("paint", (entries) => {
     for (const entry of entries) {
-      if (entry.name === "first-contentful-paint" && !reported.has("FCP")) {
-        reported.add("FCP");
+      if (entry.name === "first-contentful-paint" && !reported.has("first-contentful-paint")) {
+        reported.add("first-contentful-paint");
         const value = Math.max(entry.startTime - getActivationStart(), 0);
-        cb({
-          name: "FCP",
-          value: Math.round(value),
-          rating: getRating(value, [1800, 3e3])
-        });
+        cb("first-contentful-paint", Math.round(value));
       }
     }
   });
@@ -469,11 +349,7 @@ function observeLCP(cb) {
     const last = entries[entries.length - 1];
     if (last) {
       const value = Math.max(last.startTime - getActivationStart(), 0);
-      cb({
-        name: "LCP",
-        value: Math.round(value),
-        rating: getRating(value, [2500, 4e3])
-      });
+      cb("largest-contentful-paint", Math.round(value));
     }
   });
   if (!po) return;
@@ -484,11 +360,7 @@ function observeLCP(cb) {
     if (records.length > 0) {
       const last = records[records.length - 1];
       const value = Math.max(last.startTime - getActivationStart(), 0);
-      cb({
-        name: "LCP",
-        value: Math.round(value),
-        rating: getRating(value, [2500, 4e3])
-      });
+      cb("largest-contentful-paint", Math.round(value));
     }
     po.disconnect();
   };
@@ -516,11 +388,7 @@ function observeCLS(cb) {
       if (sessionValue > clsValue) {
         clsValue = sessionValue;
         const rounded = Math.round(clsValue * 1e4) / 1e4;
-        cb({
-          name: "CLS",
-          value: rounded,
-          rating: getRating(clsValue, [0.1, 0.25])
-        });
+        cb("cumulative-layout-shift", rounded);
       }
     }
   });
@@ -529,11 +397,7 @@ function observeTTFB(cb) {
   const nav = getNavEntry();
   if (!nav) return;
   const value = Math.max(nav.responseStart - getActivationStart(), 0);
-  cb({
-    name: "TTFB",
-    value: Math.round(value),
-    rating: getRating(value, [800, 1800])
-  });
+  cb("time-to-first-byte", Math.round(value));
 }
 function observeINP(cb) {
   const interactions = /* @__PURE__ */ new Map();
@@ -549,11 +413,7 @@ function observeINP(cb) {
           interactions.set(entry.interactionId, entry.duration);
           if (entry.duration > worstDuration) {
             worstDuration = entry.duration;
-            cb({
-              name: "INP",
-              value: Math.round(entry.duration),
-              rating: getRating(entry.duration, [200, 500])
-            });
+            cb("interaction-to-next-paint", Math.round(entry.duration));
           }
         }
       }
@@ -571,7 +431,7 @@ function observeFPS(cb) {
     if (performance.now() - start < duration) {
       requestAnimationFrame(tick);
     } else {
-      cb({ name: "FPS", value: Math.round(frames / duration * 1e3) });
+      cb("frames-per-second", Math.round(frames / duration * 1e3));
     }
   };
   if (document.readyState === "complete") {
@@ -582,74 +442,103 @@ function observeFPS(cb) {
     });
   }
 }
-function initWebVitals(cb) {
-  if (typeof window === "undefined" || typeof PerformanceObserver === "undefined")
-    return;
-  observeFCP(cb);
-  observeLCP(cb);
-  observeCLS(cb);
-  observeTTFB(cb);
-  observeINP(cb);
-  observeFPS(cb);
+function initWebVitals() {
+  const isBrowser = typeof window !== "undefined";
+  const hasPerformanceObserver = typeof PerformanceObserver !== "undefined";
+  if (!isBrowser || !hasPerformanceObserver) return [];
+  const metrics = /* @__PURE__ */ new Map();
+  observeFCP((name, value) => metrics.set(name, value));
+  observeLCP((name, value) => metrics.set(name, value));
+  observeCLS((name, value) => metrics.set(name, value));
+  observeTTFB((name, value) => metrics.set(name, value));
+  observeINP((name, value) => metrics.set(name, value));
+  observeFPS((name, value) => metrics.set(name, value));
+  return Array.from(metrics).map(([name, value]) => ({ name, value }));
 }
 
-// src/plugins/web-vitals/index.ts
-function initWebVitalsPlugin(plugeen) {
-  initWebVitals((metric) => {
-    void plugeen.events.create("web_vital", {
-      name: metric.name,
-      value: metric.value,
-      ...metric.rating !== void 0 ? { rating: metric.rating } : {}
-    });
+// src/modules/client/web-vitals/index.ts
+function initWebVitalsModule(http, logger) {
+  logger.log("Web Vitals module started");
+  http.post("/v1/web-vitals", {
+    url: window.location.href,
+    metrics: initWebVitals()
   });
 }
 
-// src/plugins/index.ts
-function initPlugins(plugeen, http, plugins) {
-  for (const plugin of plugins) {
-    if (plugin === "analytics") initAnalyticsPlugin(plugeen, http);
-    else if (plugin === "web-vitals") initWebVitalsPlugin(plugeen);
-    else if (plugin === "errors") initErrorsPlugin(plugeen);
-  }
+// src/modules/identities/index.ts
+function initIdentitiesModule(http, logger) {
+  logger.log("Identities module started");
+  return {
+    async identify(distinctId, data) {
+      const res = await http.post("/v1/identities", {
+        body: {
+          ...data,
+          id: distinctId
+        }
+      });
+      setIdentityId(distinctId);
+      return res;
+    }
+  };
+}
+
+// src/modules/server/events/index.ts
+function initEventsModule(http, logger) {
+  logger.log("Events module started");
+  return {
+    track: async (name, data = {}) => {
+      return http.post("/v1/events", { name, data, source: "sdk" });
+    }
+  };
+}
+
+// src/modules/server/feature-flags/index.ts
+function initFeatureFlagsModule(http, logger) {
+  logger.log("Feature Flags module started");
+  return {
+    get: async (name) => {
+      return http.get(`/v1/feature-flags`, { searchParams: { key: name } });
+    }
+  };
+}
+
+// src/modules/server/logs/index.ts
+function initLogsModule(http, logger) {
+  logger.log("Logs module started");
+  return {
+    send: (payload) => http.post("/v1/logs", payload)
+  };
 }
 
 // src/index.ts
 function createPlugeen(apiKey, options) {
-  if (!apiKey || typeof apiKey !== "string") {
-    throw new TypeError("[plugeen] apiKey is required");
-  }
-  if (!options?.apiUrl || typeof options.apiUrl !== "string") {
-    throw new TypeError("[plugeen] apiUrl is required");
-  }
   const resolved = {
-    apiUrl: options.apiUrl,
-    debug: options.debug ?? false,
-    disabled: options.disabled ?? false,
-    samplingRate: options.samplingRate ?? 1,
-    plugins: options.plugins ?? [],
-    skipPatterns: options.skipPatterns ?? []
+    apiUrl: "https://dev.plugeen.app/api",
+    debug: false,
+    analytics: false,
+    webVitals: false,
+    errors: false,
+    ...options
   };
+  const logger = createLogger(resolved.debug);
+  if (!apiKey) {
+    throw new TypeError("[plugeen] data-api-key is required");
+  }
   const http = new HttpClient(resolved.apiUrl, apiKey);
-  const events = createEventsModule(http, resolved);
-  const identities = createIdentitiesModule(http, resolved);
-  const featureFlags = createFeatureFlagsModule(http, resolved);
-  const logs = createLogsModule(http, resolved);
-  const surveys = createSurveysModule(http, resolved);
-  const experiments = createExperimentsModule(http, resolved);
   const plugeen = {
-    track: (event, properties) => {
-      void events.create(event, properties ?? {});
-    },
-    events,
-    identities,
-    featureFlags,
-    logs,
-    surveys,
-    experiments
+    track: initEventsModule(http, logger).track,
+    identify: initIdentitiesModule(http, logger).identify,
+    featureFlags: initFeatureFlagsModule(http, logger),
+    logs: initLogsModule(http, logger)
   };
-  if (resolved.plugins.length > 0) {
-    initPlugins(plugeen, http, resolved.plugins);
+  if (typeof window !== "undefined") {
+    if (resolved.analytics) initAnalyticsModule(http, logger);
+    if (resolved.webVitals) initWebVitalsModule(http, logger);
+    if (resolved.errors) initErrorsModule(http, logger);
   }
+  logger.log(
+    `Running on ${typeof window === "undefined" ? "server" : "client"} side`
+  );
   return plugeen;
 }