@tracelog/lib 0.0.1

package/dist/browser/web-vitals-CCnqwnC8.mjs

@@ -0,0 +1,198 @@
+var P, R = -1, h = function(e) {
+  addEventListener("pageshow", function(t) {
+    t.persisted && (R = t.timeStamp, e(t));
+  }, !0);
+}, S = function() {
+  var e = self.performance && performance.getEntriesByType && performance.getEntriesByType("navigation")[0];
+  if (e && e.responseStart > 0 && e.responseStart < performance.now()) return e;
+}, y = function() {
+  var e = S();
+  return e && e.activationStart || 0;
+}, d = function(e, t) {
+  var n = S(), i = "navigate";
+  return R >= 0 ? i = "back-forward-cache" : n && (document.prerendering || y() > 0 ? i = "prerender" : document.wasDiscarded ? i = "restore" : n.type && (i = n.type.replace(/_/g, "-"))), { name: e, value: t === void 0 ? -1 : t, rating: "good", delta: 0, entries: [], id: "v4-".concat(Date.now(), "-").concat(Math.floor(8999999999999 * Math.random()) + 1e12), navigationType: i };
+}, p = function(e, t, n) {
+  try {
+    if (PerformanceObserver.supportedEntryTypes.includes(e)) {
+      var i = new PerformanceObserver(function(r) {
+        Promise.resolve().then(function() {
+          t(r.getEntries());
+        });
+      });
+      return i.observe(Object.assign({ type: e, buffered: !0 }, n || {})), i;
+    }
+  } catch {
+  }
+}, l = function(e, t, n, i) {
+  var r, o;
+  return function(u) {
+    t.value >= 0 && (u || i) && ((o = t.value - (r || 0)) || r === void 0) && (r = t.value, t.delta = o, t.rating = function(c, a) {
+      return c > a[1] ? "poor" : c > a[0] ? "needs-improvement" : "good";
+    }(t.value, n), e(t));
+  };
+}, A = function(e) {
+  requestAnimationFrame(function() {
+    return requestAnimationFrame(function() {
+      return e();
+    });
+  });
+}, C = function(e) {
+  document.addEventListener("visibilitychange", function() {
+    document.visibilityState === "hidden" && e();
+  });
+}, I = function(e) {
+  var t = !1;
+  return function() {
+    t || (e(), t = !0);
+  };
+}, v = -1, w = function() {
+  return document.visibilityState !== "hidden" || document.prerendering ? 1 / 0 : 0;
+}, T = function(e) {
+  document.visibilityState === "hidden" && v > -1 && (v = e.type === "visibilitychange" ? e.timeStamp : 0, G());
+}, F = function() {
+  addEventListener("visibilitychange", T, !0), addEventListener("prerenderingchange", T, !0);
+}, G = function() {
+  removeEventListener("visibilitychange", T, !0), removeEventListener("prerenderingchange", T, !0);
+}, q = function() {
+  return v < 0 && (v = w(), F(), h(function() {
+    setTimeout(function() {
+      v = w(), F();
+    }, 0);
+  })), { get firstHiddenTime() {
+    return v;
+  } };
+}, E = function(e) {
+  document.prerendering ? addEventListener("prerenderingchange", function() {
+    return e();
+  }, !0) : e();
+}, M = [1800, 3e3], J = function(e, t) {
+  t = t || {}, E(function() {
+    var n, i = q(), r = d("FCP"), o = p("paint", function(u) {
+      u.forEach(function(c) {
+        c.name === "first-contentful-paint" && (o.disconnect(), c.startTime < i.firstHiddenTime && (r.value = Math.max(c.startTime - y(), 0), r.entries.push(c), n(!0)));
+      });
+    });
+    o && (n = l(e, r, M, t.reportAllChanges), h(function(u) {
+      r = d("FCP"), n = l(e, r, M, t.reportAllChanges), A(function() {
+        r.value = performance.now() - u.timeStamp, n(!0);
+      });
+    }));
+  });
+}, k = [0.1, 0.25], Y = function(e, t) {
+  t = t || {}, J(I(function() {
+    var n, i = d("CLS", 0), r = 0, o = [], u = function(a) {
+      a.forEach(function(s) {
+        if (!s.hadRecentInput) {
+          var _ = o[0], z = o[o.length - 1];
+          r && s.startTime - z.startTime < 1e3 && s.startTime - _.startTime < 5e3 ? (r += s.value, o.push(s)) : (r = s.value, o = [s]);
+        }
+      }), r > i.value && (i.value = r, i.entries = o, n());
+    }, c = p("layout-shift", u);
+    c && (n = l(e, i, k, t.reportAllChanges), C(function() {
+      u(c.takeRecords()), n(!0);
+    }), h(function() {
+      r = 0, i = d("CLS", 0), n = l(e, i, k, t.reportAllChanges), A(function() {
+        return n();
+      });
+    }), setTimeout(n, 0));
+  }));
+}, H = 0, b = 1 / 0, m = 0, K = function(e) {
+  e.forEach(function(t) {
+    t.interactionId && (b = Math.min(b, t.interactionId), m = Math.max(m, t.interactionId), H = m ? (m - b) / 7 + 1 : 0);
+  });
+}, O = function() {
+  return P ? H : performance.interactionCount || 0;
+}, Q = function() {
+  "interactionCount" in performance || P || (P = p("event", K, { type: "event", buffered: !0, durationThreshold: 0 }));
+}, f = [], g = /* @__PURE__ */ new Map(), D = 0, U = function() {
+  var e = Math.min(f.length - 1, Math.floor((O() - D) / 50));
+  return f[e];
+}, V = [], W = function(e) {
+  if (V.forEach(function(r) {
+    return r(e);
+  }), e.interactionId || e.entryType === "first-input") {
+    var t = f[f.length - 1], n = g.get(e.interactionId);
+    if (n || f.length < 10 || e.duration > t.latency) {
+      if (n) e.duration > n.latency ? (n.entries = [e], n.latency = e.duration) : e.duration === n.latency && e.startTime === n.entries[0].startTime && n.entries.push(e);
+      else {
+        var i = { id: e.interactionId, latency: e.duration, entries: [e] };
+        g.set(i.id, i), f.push(i);
+      }
+      f.sort(function(r, o) {
+        return o.latency - r.latency;
+      }), f.length > 10 && f.splice(10).forEach(function(r) {
+        return g.delete(r.id);
+      });
+    }
+  }
+}, j = function(e) {
+  var t = self.requestIdleCallback || self.setTimeout, n = -1;
+  return e = I(e), document.visibilityState === "hidden" ? e() : (n = t(e), C(e)), n;
+}, B = [200, 500], Z = function(e, t) {
+  "PerformanceEventTiming" in self && "interactionId" in PerformanceEventTiming.prototype && (t = t || {}, E(function() {
+    var n;
+    Q();
+    var i, r = d("INP"), o = function(c) {
+      j(function() {
+        c.forEach(W);
+        var a = U();
+        a && a.latency !== r.value && (r.value = a.latency, r.entries = a.entries, i());
+      });
+    }, u = p("event", o, { durationThreshold: (n = t.durationThreshold) !== null && n !== void 0 ? n : 40 });
+    i = l(e, r, B, t.reportAllChanges), u && (u.observe({ type: "first-input", buffered: !0 }), C(function() {
+      o(u.takeRecords()), i(!0);
+    }), h(function() {
+      D = O(), f.length = 0, g.clear(), r = d("INP"), i = l(e, r, B, t.reportAllChanges);
+    }));
+  }));
+}, x = [2500, 4e3], L = {}, $ = function(e, t) {
+  t = t || {}, E(function() {
+    var n, i = q(), r = d("LCP"), o = function(a) {
+      t.reportAllChanges || (a = a.slice(-1)), a.forEach(function(s) {
+        s.startTime < i.firstHiddenTime && (r.value = Math.max(s.startTime - y(), 0), r.entries = [s], n());
+      });
+    }, u = p("largest-contentful-paint", o);
+    if (u) {
+      n = l(e, r, x, t.reportAllChanges);
+      var c = I(function() {
+        L[r.id] || (o(u.takeRecords()), u.disconnect(), L[r.id] = !0, n(!0));
+      });
+      ["keydown", "click"].forEach(function(a) {
+        addEventListener(a, function() {
+          return j(c);
+        }, { once: !0, capture: !0 });
+      }), C(c), h(function(a) {
+        r = d("LCP"), n = l(e, r, x, t.reportAllChanges), A(function() {
+          r.value = performance.now() - a.timeStamp, L[r.id] = !0, n(!0);
+        });
+      });
+    }
+  });
+}, N = [800, 1800], X = function e(t) {
+  document.prerendering ? E(function() {
+    return e(t);
+  }) : document.readyState !== "complete" ? addEventListener("load", function() {
+    return e(t);
+  }, !0) : setTimeout(t, 0);
+}, ee = function(e, t) {
+  t = t || {};
+  var n = d("TTFB"), i = l(e, n, N, t.reportAllChanges);
+  X(function() {
+    var r = S();
+    r && (n.value = Math.max(r.responseStart - y(), 0), n.entries = [r], i(!0), h(function() {
+      n = d("TTFB", 0), (i = l(e, n, N, t.reportAllChanges))(!0);
+    }));
+  });
+};
+export {
+  k as CLSThresholds,
+  M as FCPThresholds,
+  B as INPThresholds,
+  x as LCPThresholds,
+  N as TTFBThresholds,
+  Y as onCLS,
+  J as onFCP,
+  Z as onINP,
+  $ as onLCP,
+  ee as onTTFB
+};

package/dist/cjs/api.d.ts

@@ -0,0 +1,46 @@
+import { MetadataType } from './types/common.types';
+import { AppConfig } from './types/config.types';
+import './types/window.types';
+export * as Types from './app.types';
+export * as Constants from './app.constants';
+/**
+ * Initializes the tracelog app with the provided configuration.
+ * If already initialized, this function returns early without error.
+ * @param appConfig - The configuration object for the app
+ * @throws {Error} If initialization is currently in progress
+ * @example
+ * await init({ id: 'my-project-id' });
+ */
+export declare const init: (appConfig: AppConfig) => Promise<void>;
+/**
+ * Sends a custom event with the specified name and metadata.
+ * @param name - The name of the custom event.
+ * @param metadata - Optional metadata to attach to the event.
+ * @example
+ * // Send a custom event with metadata
+ * event('user_signup', { method: 'email', plan: 'premium' });
+ * @example
+ * // Send a custom event without metadata
+ * event('user_login');
+ * @remarks
+ * This function should be called after the app has been initialized using the `init` function.
+ */
+export declare const event: (name: string, metadata?: Record<string, MetadataType>) => void;
+/**
+ * Checks if the app has been initialized.
+ * @returns true if the app is initialized, false otherwise
+ */
+export declare const isInitialized: () => boolean;
+/**
+ * Gets the current initialization status for debugging purposes.
+ * @returns Object with detailed initialization state
+ */
+export declare const getInitializationStatus: () => {
+    isInitialized: boolean;
+    isInitializing: boolean;
+    hasInstance: boolean;
+};
+/**
+ * Destroys the current app instance and cleans up resources.
+ */
+export declare const destroy: () => void;

package/dist/cjs/api.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroy = exports.getInitializationStatus = exports.isInitialized = exports.event = exports.init = exports.Constants = exports.Types = void 0;
+const app_1 = require("./app");
+const logging_1 = require("./utils/logging");
+const validations_1 = require("./utils/validations");
+const constants_1 = require("./constants");
+require("./types/window.types");
+exports.Types = __importStar(require("./app.types"));
+exports.Constants = __importStar(require("./app.constants"));
+let app = null;
+let isInitializing = false;
+/**
+ * Initializes the tracelog app with the provided configuration.
+ * If already initialized, this function returns early without error.
+ * @param appConfig - The configuration object for the app
+ * @throws {Error} If initialization is currently in progress
+ * @example
+ * await init({ id: 'my-project-id' });
+ */
+const init = async (appConfig) => {
+    try {
+        logging_1.debugLog.info('API', 'Library initialization started', { id: appConfig.id });
+        if (typeof window === 'undefined' || typeof document === 'undefined') {
+            logging_1.debugLog.clientError('API', 'Browser environment required - this library can only be used in a browser environment', {
+                hasWindow: typeof window !== 'undefined',
+                hasDocument: typeof document !== 'undefined',
+            });
+            throw new Error('This library can only be used in a browser environment');
+        }
+        if (app) {
+            logging_1.debugLog.debug('API', 'Library already initialized, skipping duplicate initialization', {
+                projectId: appConfig.id,
+            });
+            return;
+        }
+        if (isInitializing) {
+            logging_1.debugLog.debug('API', 'Concurrent initialization detected, waiting for completion', { projectId: appConfig.id });
+            let retries = 0;
+            const maxRetries = constants_1.INITIALIZATION_CONSTANTS.MAX_CONCURRENT_RETRIES;
+            const retryDelay = constants_1.INITIALIZATION_CONSTANTS.CONCURRENT_RETRY_DELAY_MS;
+            while (isInitializing && retries < maxRetries) {
+                await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                retries++;
+            }
+            if (app) {
+                logging_1.debugLog.debug('API', 'Concurrent initialization completed successfully', {
+                    projectId: appConfig.id,
+                    retriesUsed: retries,
+                });
+                return;
+            }
+            if (isInitializing) {
+                logging_1.debugLog.error('API', 'Initialization timeout - concurrent initialization took too long', {
+                    projectId: appConfig.id,
+                    retriesUsed: retries,
+                    maxRetries,
+                });
+                throw new Error('App initialization timeout - concurrent initialization took too long');
+            }
+        }
+        isInitializing = true;
+        logging_1.debugLog.debug('API', 'Validating and normalizing configuration', { projectId: appConfig.id });
+        const validatedConfig = (0, validations_1.validateAndNormalizeConfig)(appConfig);
+        logging_1.debugLog.debug('API', 'Creating App instance', { projectId: validatedConfig.id });
+        const instance = new app_1.App();
+        await instance.init(validatedConfig);
+        app = instance;
+        logging_1.debugLog.info('API', 'Library initialization completed successfully', {
+            projectId: validatedConfig.id,
+        });
+    }
+    catch (error) {
+        // Ensure complete cleanup on initialization failure
+        if (app && !app.initialized) {
+            // Clean up partially initialized app instance
+            try {
+                app.destroy();
+            }
+            catch (cleanupError) {
+                logging_1.debugLog.warn('API', 'Failed to cleanup partially initialized app', { cleanupError });
+            }
+        }
+        app = null;
+        logging_1.debugLog.error('API', 'Initialization failed', { error });
+        throw error;
+    }
+    finally {
+        isInitializing = false;
+    }
+};
+exports.init = init;
+/**
+ * Sends a custom event with the specified name and metadata.
+ * @param name - The name of the custom event.
+ * @param metadata - Optional metadata to attach to the event.
+ * @example
+ * // Send a custom event with metadata
+ * event('user_signup', { method: 'email', plan: 'premium' });
+ * @example
+ * // Send a custom event without metadata
+ * event('user_login');
+ * @remarks
+ * This function should be called after the app has been initialized using the `init` function.
+ */
+const event = (name, metadata) => {
+    try {
+        if (!app) {
+            logging_1.debugLog.clientError('API', 'Custom event failed - Library not initialized. Please call TraceLog.init() first', {
+                eventName: name,
+                hasMetadata: !!metadata,
+            });
+            throw new Error('App not initialized');
+        }
+        logging_1.debugLog.debug('API', 'Sending custom event', {
+            eventName: name,
+            hasMetadata: !!metadata,
+            metadataKeys: metadata ? Object.keys(metadata) : [],
+        });
+        app.sendCustomEvent(name, metadata);
+    }
+    catch (error) {
+        logging_1.debugLog.error('API', 'Event tracking failed', { eventName: name, error, hasMetadata: !!metadata });
+        if (error instanceof Error &&
+            (error.message === 'App not initialized' || error.message.includes('validation failed'))) {
+            throw error;
+        }
+    }
+};
+exports.event = event;
+/**
+ * Checks if the app has been initialized.
+ * @returns true if the app is initialized, false otherwise
+ */
+const isInitialized = () => {
+    return app !== null;
+};
+exports.isInitialized = isInitialized;
+/**
+ * Gets the current initialization status for debugging purposes.
+ * @returns Object with detailed initialization state
+ */
+const getInitializationStatus = () => {
+    return {
+        isInitialized: app !== null,
+        isInitializing: isInitializing,
+        hasInstance: app !== null,
+    };
+};
+exports.getInitializationStatus = getInitializationStatus;
+/**
+ * Destroys the current app instance and cleans up resources.
+ */
+const destroy = () => {
+    try {
+        logging_1.debugLog.info('API', 'Library cleanup initiated');
+        if (!app) {
+            logging_1.debugLog.warn('API', 'Cleanup called but Library was not initialized');
+            throw new Error('App not initialized');
+        }
+        app.destroy();
+        app = null;
+        isInitializing = false;
+        logging_1.debugLog.info('API', 'Library cleanup completed successfully');
+    }
+    catch (error) {
+        logging_1.debugLog.error('API', 'Cleanup failed', { error, hadApp: !!app, wasInitializing: isInitializing });
+    }
+};
+exports.destroy = destroy;
+class TestBridge extends app_1.App {
+    isInitializing() {
+        return isInitializing;
+    }
+}
+// Auto-inject testing bridge only in development/testing environments
+if (process.env.NODE_ENV === 'dev') {
+    if (typeof window !== 'undefined') {
+        // Wait for DOM to be ready before injecting
+        const injectTestingBridge = () => {
+            window.__traceLogBridge = new TestBridge();
+        };
+        // Inject immediately if DOM is ready, otherwise wait
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', injectTestingBridge);
+        }
+        else {
+            injectTestingBridge();
+        }
+    }
+}

package/dist/cjs/app.constants.d.ts

@@ -0,0 +1 @@
+export { DEFAULT_SESSION_TIMEOUT_MS } from './constants';

package/dist/cjs/app.constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SESSION_TIMEOUT_MS = void 0;
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "DEFAULT_SESSION_TIMEOUT_MS", { enumerable: true, get: function () { return constants_1.DEFAULT_SESSION_TIMEOUT_MS; } });

package/dist/cjs/app.d.ts

@@ -0,0 +1,59 @@
+import { EventManager } from './managers/event.manager';
+import { AppConfig } from './types/config.types';
+import { StateManager } from './managers/state.manager';
+import { SessionHandler } from './handlers/session.handler';
+import { PageViewHandler } from './handlers/page-view.handler';
+import { ClickHandler } from './handlers/click.handler';
+import { ScrollHandler } from './handlers/scroll.handler';
+import { GoogleAnalyticsIntegration } from './integrations/google-analytics.integration';
+import { StorageManager } from './managers/storage.manager';
+import { PerformanceHandler } from './handlers/performance.handler';
+import { ErrorHandler } from './handlers/error.handler';
+import { NetworkHandler } from './handlers/network.handler';
+export declare class App extends StateManager {
+    protected isInitialized: boolean;
+    protected googleAnalytics: GoogleAnalyticsIntegration | null;
+    protected storageManager: StorageManager;
+    protected eventManager: EventManager;
+    protected sessionHandler: SessionHandler;
+    protected pageViewHandler: PageViewHandler;
+    protected clickHandler: ClickHandler;
+    protected scrollHandler: ScrollHandler;
+    protected performanceHandler: PerformanceHandler;
+    protected errorHandler: ErrorHandler;
+    protected networkHandler: NetworkHandler;
+    protected suppressNextScrollTimer: number | null;
+    /**
+     * Returns the initialization status of the app
+     * @returns true if the app is fully initialized, false otherwise
+     */
+    get initialized(): boolean;
+    init(appConfig: AppConfig): Promise<void>;
+    /**
+     * Validates that the app is ready to initialize with the provided config
+     * This is a lightweight runtime validation layer that ensures the app receives proper config
+     * @param appConfig - The validated and normalized configuration
+     * @throws {ProjectIdValidationError} If project ID is invalid at runtime
+     */
+    private validateAppReadiness;
+    sendCustomEvent(name: string, metadata?: Record<string, unknown>): void;
+    destroy(): void;
+    private setState;
+    private setApiUrl;
+    private setConfig;
+    private setUserId;
+    private setDevice;
+    private setPageUrl;
+    private setIntegrations;
+    private initHandlers;
+    private initStorage;
+    private setEventManager;
+    private initSessionHandler;
+    private initPageViewHandler;
+    private onPageViewTrack;
+    private initClickHandler;
+    private initScrollHandler;
+    private initPerformanceHandler;
+    private initErrorHandler;
+    private initNetworkHandler;
+}