@v-tilt/browser 1.0.7 → 1.0.9

package/lib/vtilt.js

@@ -4,10 +4,13 @@ exports.VTilt = void 0;
 exports.init_as_module = init_as_module;
 exports.init_from_snippet = init_from_snippet;
 const config_1 = require("./config");
-const tracking_1 = require("./tracking");
+const session_1 = require("./session");
+const user_manager_1 = require("./user-manager");
 const web_vitals_1 = require("./web-vitals");
 const history_autocapture_1 = require("./extensions/history-autocapture");
 const utils_1 = require("./utils");
+const event_utils_1 = require("./utils/event-utils");
+const utils_2 = require("./utils");
 const globals_1 = require("./utils/globals");
 // Helper to check if value is an array
 const isArray = Array.isArray;
@@ -16,9 +19,18 @@ class VTilt {
         this.__loaded = false; // Matches snippet's window.vt.__loaded check
         this._initialPageviewCaptured = false;
         this._visibilityStateListener = null;
+        this.__request_queue = []; // Public for DOM loaded handler
+        this._hasWarnedAboutConfig = false; // Track if we've already warned about missing config
         this.configManager = new config_1.ConfigManager(config);
-        this.trackingManager = new tracking_1.TrackingManager(this.configManager.getConfig());
-        this.webVitalsManager = new web_vitals_1.WebVitalsManager(this.configManager.getConfig(), this.trackingManager);
+        const fullConfig = this.configManager.getConfig();
+        // Auto-detect domain from location if not provided
+        let domain = fullConfig.domain;
+        if (!domain && globals_1.location) {
+            domain = this.getCurrentDomain();
+        }
+        this.sessionManager = new session_1.SessionManager(fullConfig.storage || "cookie", domain);
+        this.userManager = new user_manager_1.UserManager(fullConfig.persistence || "localStorage", domain);
+        this.webVitalsManager = new web_vitals_1.WebVitalsManager(fullConfig, this);
     }
     /**
      * Initializes a new instance of the VTilt tracking object.
@@ -68,7 +80,6 @@ class VTilt {
     /**
      * Handles the actual initialization logic for a VTilt instance.
      * This internal method should only be called by `init()`.
-     * Follows the PostHog convention of using a private `_init()` method for instance setup.
      */
     _init(projectId, config = {}, name) {
         // Guard: prevent re-initialization (matches snippet's __loaded check)
@@ -76,14 +87,14 @@ class VTilt {
             console.warn("vTilt: You have already initialized vTilt! Re-initializing is a no-op");
             return this;
         }
-        // Update config with projectId, token, and name (PostHog-style)
+        // Update config with projectId, token, and name
         this.updateConfig({
             ...config,
             projectId: projectId || config.projectId,
             name: name,
         });
         this.__loaded = true;
-        // Initialize history autocapture (PostHog-style)
+        // Initialize history autocapture
         this.historyAutocapture = new history_autocapture_1.HistoryAutocapture(this);
         this.historyAutocapture.startIfEnabled();
         // Capture initial pageview (with visibility check)
@@ -91,7 +102,7 @@ class VTilt {
         return this;
     }
     /**
-     * Returns a string representation of the instance name (PostHog-style)
+     * Returns a string representation of the instance name
      * Used for debugging and logging
      *
      * @internal
@@ -106,14 +117,191 @@ class VTilt {
         return name;
     }
     /**
-     * Track a custom event
+     * Get current domain from location
+     * Returns full URL format for consistency with dashboard
+     */
+    getCurrentDomain() {
+        if (!globals_1.location) {
+            return "";
+        }
+        const protocol = globals_1.location.protocol;
+        const hostname = globals_1.location.hostname;
+        const port = globals_1.location.port;
+        const portSuffix = port ? `:${port}` : "";
+        return `${protocol}//${hostname}${portSuffix}`;
+    }
+    /**
+     * Check if tracking is properly configured
+     * Returns true if projectId and token are present, false otherwise
+     * Logs a warning only once per instance if not configured
+     */
+    _isConfigured() {
+        const config = this.configManager.getConfig();
+        if (config.projectId && config.token) {
+            return true;
+        }
+        // Only warn once to avoid console spam
+        if (!this._hasWarnedAboutConfig) {
+            console.warn("VTilt: projectId and token are required for tracking. " +
+                "Events will be skipped until init() or updateConfig() is called with these fields.");
+            this._hasWarnedAboutConfig = true;
+        }
+        return false;
+    }
+    /**
+     * Build the tracking URL with token in query parameters
+     */
+    buildUrl() {
+        const config = this.configManager.getConfig();
+        const { proxyUrl, proxy, host, token } = config;
+        // Use proxy endpoint to handle Tinybird authentication
+        if (proxyUrl) {
+            // Use the full proxy URL as provided
+            return proxyUrl;
+        }
+        else if (proxy) {
+            // Construct the proxy URL from the proxy domain with token
+            return `${proxy}/api/tracking?token=${token}`;
+        }
+        else if (host) {
+            const cleanHost = host.replace(/\/+$/gm, "");
+            return `${cleanHost}/api/tracking?token=${token}`;
+        }
+        else {
+            // Use relative path to our tracking proxy endpoint
+            return `/api/tracking?token=${token}`;
+        }
+    }
+    /**
+     * Send HTTP request
+     * This is the central entry point for all tracking requests
+     */
+    sendRequest(url, event, shouldEnqueue) {
+        // Validate configuration (only warns once per instance)
+        // This is the single place where validation happens for all sending methods
+        if (!this._isConfigured()) {
+            return;
+        }
+        // Check if we should queue requests (for older browsers before DOM is loaded)
+        if (shouldEnqueue && typeof globals_1.window !== "undefined") {
+            // ENQUEUE_REQUESTS is defined in vtilt.ts as a module-level variable
+            const ENQUEUE_REQUESTS = globals_1.window.__VTILT_ENQUEUE_REQUESTS;
+            if (ENQUEUE_REQUESTS) {
+                this.__request_queue.push({ url, event });
+                return;
+            }
+        }
+        const request = new XMLHttpRequest();
+        request.open("POST", url, true);
+        request.setRequestHeader("Content-Type", "application/json");
+        request.send(JSON.stringify(event));
+    }
+    /**
+     * Send a queued request (called after DOM is loaded)
+     */
+    _send_retriable_request(item) {
+        this.sendRequest(item.url, item.event, false);
+    }
+    /**
+     * Capture an event
+     * Automatically adds common properties to all events
+     * ($current_url, $host, $pathname, $referrer, $referring_domain, $browser_language, etc.)
+     * Also adds title property for $pageview events only
+     *
+     * @param name - Event name
+     * @param payload - Event payload
+     */
+    capture(name, payload) {
+        this.sessionManager.setSessionId();
+        // Only send events in browser environment (not SSR)
+        if (!globals_1.navigator || !globals_1.navigator.userAgent) {
+            return;
+        }
+        if (!(0, utils_1.isValidUserAgent)(globals_1.navigator.userAgent)) {
+            return;
+        }
+        const url = this.buildUrl();
+        // Add properties to all events
+        // This includes: $current_url, $host, $pathname, $referrer, $referring_domain, $browser_language, etc.
+        const eventProperties = (0, event_utils_1.getEventProperties)();
+        // Get person properties (includes $device_id and other user properties)
+        // These are automatically included in all events
+        const personProperties = this.userManager.getUserProperties();
+        // Get session and window IDs
+        // Both methods ensure IDs always exist (generate if needed)
+        const session_id = this.sessionManager.getSessionId();
+        const window_id = this.sessionManager.getWindowId();
+        // Always include anonymous_id in properties for identity linking
+        // This allows linking events with different distinct_ids that share the same anonymous_id
+        // This is especially important for handling race conditions when $identify events arrive
+        const anonymousId = this.userManager.getAnonymousId();
+        const enrichedPayload = {
+            ...eventProperties, // Base properties for all events
+            ...personProperties, // Person properties (includes $device_id)
+            $session_id: session_id, // Session ID in properties
+            $window_id: window_id, // Window ID in properties
+            // Always include $anon_distinct_id for identity linking (even for identified users)
+            // This allows the server to merge identities proactively when events arrive out of order
+            ...(anonymousId ? { $anon_distinct_id: anonymousId } : {}),
+            ...payload, // User-provided payload (can override base and person properties)
+        };
+        // Add title only to $pageview events
+        if (name === "$pageview" && globals_1.document) {
+            enrichedPayload.title = globals_1.document.title;
+        }
+        const config = this.configManager.getConfig();
+        let processedPayload;
+        if (config.stringifyPayload !== false) {
+            processedPayload = Object.assign({}, enrichedPayload, config.globalAttributes);
+            processedPayload = JSON.stringify(processedPayload);
+            if (!(0, utils_1.isValidPayload)(processedPayload)) {
+                return;
+            }
+        }
+        else {
+            processedPayload = Object.assign({}, enrichedPayload, config.globalAttributes);
+            const payloadStr = JSON.stringify(processedPayload);
+            if (!(0, utils_1.isValidPayload)(payloadStr)) {
+                return;
+            }
+        }
+        // Use current distinct_id (or anonymous_id) for event's distinct_id
+        // For $identify events, use anonymous_id as the event's distinct_id (identifying FROM anonymous TO new ID)
+        // New distinct_id should be in payload properties (e.g., for $identify events)
+        let distinct_id;
+        if (name === "$identify") {
+            // For $identify events, always use anonymous_id as the event's distinct_id
+            // The new distinct_id is in the payload
+            distinct_id = this.userManager.getAnonymousId();
+        }
+        else {
+            // For other events, use current distinct_id or fall back to anonymous_id
+            distinct_id =
+                this.userManager.getDistinctId() || this.userManager.getAnonymousId();
+        }
+        const trackingEvent = {
+            timestamp: new Date().toISOString(),
+            event: name,
+            tenant_id: config.projectId || "",
+            domain: config.domain || this.getCurrentDomain(), // Use config domain or current domain
+            payload: processedPayload,
+            distinct_id: distinct_id,
+            // Always include anonymous_id in the event for identity linking
+            // This allows the server to merge identities proactively
+            anonymous_id: anonymousId,
+        };
+        this.sendRequest(url, trackingEvent, true);
+    }
+    /**
+     * Track a custom event (alias for capture)
      */
     trackEvent(name, payload = {}) {
-        this.trackingManager.sendEvent(name, payload);
+        this.capture(name, payload);
     }
     /**
-     * Identify a user with PostHog-style property operations
-     * Copied from PostHog's identify method signature
+     * Identify a user with property operations
+     * Sends $identify event when transitioning from anonymous to identified
+     * Event's distinct_id is the previous/anonymous ID, new distinct_id is in payload
      *
      * @example
      * ```js
@@ -130,11 +318,76 @@ class VTilt {
      * vTilt.identify('user_123', { name: 'John Doe', email: 'john@example.com' })
      * ```
      */
-    identify(distinctId, userPropertiesToSet, userPropertiesToSetOnce) {
-        this.trackingManager.identify(distinctId, userPropertiesToSet, userPropertiesToSetOnce);
+    identify(newDistinctId, userPropertiesToSet, userPropertiesToSetOnce) {
+        // Validation: Convert number to string
+        if (typeof newDistinctId === "number") {
+            newDistinctId = String(newDistinctId);
+            console.warn("The first argument to vTilt.identify was a number, but it should be a string. It has been converted to a string.");
+        }
+        // Validation: Check if distinct_id is provided
+        if (!newDistinctId) {
+            console.error("Unique user id has not been set in vTilt.identify");
+            return;
+        }
+        // Validation: Check for hardcoded strings
+        if (this.userManager.isDistinctIdStringLikePublic(newDistinctId)) {
+            console.error(`The string "${newDistinctId}" was set in vTilt.identify which indicates an error. This ID should be unique to the user and not a hardcoded string.`);
+            return;
+        }
+        // Validation: Check for cookieless sentinel value
+        if (newDistinctId === "COOKIELESS_SENTINEL_VALUE") {
+            console.error(`The string "${newDistinctId}" was set in vTilt.identify which indicates an error. This ID is only used as a sentinel value.`);
+            return;
+        }
+        const previousDistinctId = this.userManager.getDistinctId();
+        const anonymousId = this.userManager.getAnonymousId();
+        const deviceId = this.userManager.getDeviceId();
+        const isKnownAnonymous = this.userManager.getUserState() === "anonymous";
+        // Handle device ID if not already set
+        if (!deviceId) {
+            const device_id = previousDistinctId || anonymousId;
+            this.userManager.ensureDeviceId(device_id);
+        }
+        // Send $identify event when distinct_id is changing AND user was anonymous
+        // Event's distinct_id is the previous/anonymous ID, new distinct_id goes in payload
+        if (newDistinctId !== previousDistinctId && isKnownAnonymous) {
+            // Update user state and properties BEFORE sending event
+            // (But don't update distinct_id yet - sendEvent needs to use previous ID)
+            this.userManager.setUserState("identified");
+            this.userManager.updateUserProperties(userPropertiesToSet, userPropertiesToSetOnce);
+            // Send $identify event with previous/anonymous ID as event's distinct_id
+            // New distinct_id and properties go in payload
+            this.capture("$identify", {
+                distinct_id: newDistinctId, // New distinct_id in payload
+                $anon_distinct_id: previousDistinctId || anonymousId, // Previous ID in payload
+                $set: userPropertiesToSet || {},
+                $set_once: userPropertiesToSetOnce || {},
+            });
+            // Now update distinct_id after sending the event
+            this.userManager.setDistinctId(newDistinctId);
+        }
+        else if (userPropertiesToSet || userPropertiesToSetOnce) {
+            // If distinct_id is not changing but we have properties to set
+            // Update user state if not already identified
+            if (isKnownAnonymous) {
+                this.userManager.setUserState("identified");
+            }
+            // Update properties
+            this.userManager.updateUserProperties(userPropertiesToSet, userPropertiesToSetOnce);
+            // Send $set event to notify server of property updates
+            this.capture("$set", {
+                $set: userPropertiesToSet || {},
+                $set_once: userPropertiesToSetOnce || {},
+            });
+        }
+        else if (newDistinctId !== previousDistinctId) {
+            // If distinct_id is changing but user was already identified, just update the distinct_id
+            this.userManager.setUserState("identified");
+            this.userManager.setDistinctId(newDistinctId);
+        }
     }
     /**
-     * Set user properties with PostHog-style operations
+     * Set user properties
      * Sets properties on the person profile associated with the current distinct_id
      *
      * @example
@@ -156,11 +409,20 @@ class VTilt {
      * @param userPropertiesToSetOnce Optional: Properties to set once (preserves first value)
      */
     setUserProperties(userPropertiesToSet, userPropertiesToSetOnce) {
-        this.trackingManager.setUserProperties(userPropertiesToSet, userPropertiesToSetOnce);
+        // Update user properties in UserManager
+        // Returns true if properties were updated (not a duplicate), false otherwise
+        const shouldSendEvent = this.userManager.setUserProperties(userPropertiesToSet, userPropertiesToSetOnce);
+        // Only send $set event if properties were actually updated (not a duplicate)
+        if (shouldSendEvent) {
+            this.capture("$set", {
+                $set: userPropertiesToSet || {},
+                $set_once: userPropertiesToSetOnce || {},
+            });
+        }
     }
     /**
      * Reset user identity (logout)
-     * PostHog behavior: Clears all user data, generates new anonymous ID
+     * Clears all user data, generates new anonymous ID, resets session
      *
      * @param reset_device_id - If true, also resets device_id. Default: false
      *
@@ -173,29 +435,31 @@ class VTilt {
      * vtilt.resetUser(true)
      */
     resetUser(reset_device_id) {
-        this.trackingManager.resetUser(reset_device_id);
+        // Reset session ID
+        this.sessionManager.resetSessionId();
+        this.userManager.reset(reset_device_id);
     }
     /**
      * Get current user identity
      */
     getUserIdentity() {
-        return this.trackingManager.getUserIdentity();
+        return this.userManager.getUserIdentity();
     }
     /**
      * Get current device ID
      */
     getDeviceId() {
-        return this.trackingManager.getDeviceId();
+        return this.userManager.getDeviceId();
     }
     /**
      * Get current user state
      */
     getUserState() {
-        return this.trackingManager.getUserState();
+        return this.userManager.getUserState();
     }
     /**
      * Create an alias to link two distinct IDs
-     * PostHog behavior: Links anonymous session to account on signup
+     * Links anonymous session to account on signup
      *
      * @param alias - A unique identifier that you want to use for this user in the future
      * @param original - The current identifier being used for this user (optional, defaults to current distinct_id)
@@ -209,11 +473,27 @@ class VTilt {
      * vtilt.createAlias('user_12345', 'anonymous_abc123')
      */
     createAlias(alias, original) {
-        this.trackingManager.createAlias(alias, original);
+        // Get alias information from UserManager
+        const aliasInfo = this.userManager.createAlias(alias, original);
+        // If alias was created, send $alias event
+        if (aliasInfo) {
+            this.capture("$alias", {
+                $original_id: aliasInfo.original,
+                $alias_id: aliasInfo.distinct_id,
+            });
+        }
+        else {
+            // If alias matches original, use identify instead
+            const distinctId = original ||
+                this.userManager.getDistinctId() ||
+                this.userManager.getAnonymousId();
+            if (alias === distinctId) {
+                this.identify(alias);
+            }
+        }
     }
     /**
      * Capture initial pageview with visibility check
-     * Based on PostHog's _captureInitialPageview implementation
      */
     _captureInitialPageview() {
         if (!globals_1.document) {
@@ -228,25 +508,25 @@ class VTilt {
                 this._visibilityStateListener = () => {
                     this._captureInitialPageview();
                 };
-                (0, utils_1.addEventListener)(globals_1.document, "visibilitychange", this._visibilityStateListener);
+                (0, utils_2.addEventListener)(globals_1.document, "visibilitychange", this._visibilityStateListener);
             }
             return;
         }
         // Extra check here to guarantee we only ever trigger a single initial pageview event
         if (!this._initialPageviewCaptured) {
             this._initialPageviewCaptured = true;
-            // Wait a bit for SPA routers (PostHog-style delay)
+            // Wait a bit for SPA routers
             setTimeout(() => {
                 // Double-check we're still in browser environment (defensive check)
                 if (!globals_1.document || !globals_1.location) {
                     return;
                 }
                 // Note: $current_url, $host, $pathname, $referrer, $referring_domain, title
-                // are automatically added by sendEvent() for all events (title only for $pageview)
+                // are automatically added by capture() for all events (title only for $pageview)
                 const payload = {
                     navigation_type: "initial_load",
                 };
-                this.trackingManager.sendEvent("$pageview", payload);
+                this.capture("$pageview", payload);
             }, 300);
             // After we've captured the initial pageview, we can remove the listener
             if (this._visibilityStateListener) {
@@ -265,16 +545,22 @@ class VTilt {
      * Get current session ID
      */
     getSessionId() {
-        return this.trackingManager.getSessionId();
+        return this.sessionManager.getSessionId();
     }
     /**
      * Update configuration
      */
     updateConfig(config) {
         this.configManager.updateConfig(config);
+        const fullConfig = this.configManager.getConfig();
         // Recreate managers with new config
-        this.trackingManager = new tracking_1.TrackingManager(this.configManager.getConfig());
-        this.webVitalsManager = new web_vitals_1.WebVitalsManager(this.configManager.getConfig(), this.trackingManager);
+        let domain = fullConfig.domain;
+        if (!domain && globals_1.location) {
+            domain = this.getCurrentDomain();
+        }
+        this.sessionManager = new session_1.SessionManager(fullConfig.storage || "cookie", domain);
+        this.userManager = new user_manager_1.UserManager(fullConfig.persistence || "localStorage", domain);
+        this.webVitalsManager = new web_vitals_1.WebVitalsManager(fullConfig, this);
     }
     /**
      * _execute_array() deals with processing any vTilt function
@@ -310,14 +596,12 @@ class VTilt {
      * Called when DOM is loaded - processes queued requests
      */
     _dom_loaded() {
-        if (this.trackingManager) {
-            // Process all queued requests
-            this.trackingManager.__request_queue.forEach((item) => {
-                this.trackingManager._send_retriable_request(item);
-            });
-            // Clear the queue
-            this.trackingManager.__request_queue = [];
-        }
+        // Process all queued requests
+        this.__request_queue.forEach((item) => {
+            this._send_retriable_request(item);
+        });
+        // Clear the queue
+        this.__request_queue = [];
     }
 }
 exports.VTilt = VTilt;
@@ -331,13 +615,12 @@ const SUPPORTS_REQUEST = typeof globals_1.XMLHttpRequest !== "undefined" || type
 let ENQUEUE_REQUESTS = !SUPPORTS_REQUEST &&
     (globals_1.userAgent === null || globals_1.userAgent === void 0 ? void 0 : globals_1.userAgent.indexOf("MSIE")) === -1 &&
     (globals_1.userAgent === null || globals_1.userAgent === void 0 ? void 0 : globals_1.userAgent.indexOf("Mozilla")) === -1;
-// Expose ENQUEUE_REQUESTS to window for TrackingManager to access
+// Expose ENQUEUE_REQUESTS to window for request queuing
 if (globals_1.window) {
     globals_1.window.__VTILT_ENQUEUE_REQUESTS = ENQUEUE_REQUESTS;
 }
 /**
  * Add DOM loaded handler to process queued requests
- * Similar to PostHog's add_dom_loaded_handler
  */
 const add_dom_loaded_handler = function () {
     // Cross browser DOM Loaded support
@@ -353,7 +636,7 @@ const add_dom_loaded_handler = function () {
             globals_1.window.__VTILT_ENQUEUE_REQUESTS = false;
         }
         // Process queued requests for all instances
-        (0, utils_1.each)(instances, function (inst) {
+        (0, utils_2.each)(instances, function (inst) {
             inst._dom_loaded();
         });
     }
@@ -366,7 +649,7 @@ const add_dom_loaded_handler = function () {
             dom_loaded_handler();
         }
         else {
-            (0, utils_1.addEventListener)(globals_1.document, "DOMContentLoaded", dom_loaded_handler, {
+            (0, utils_2.addEventListener)(globals_1.document, "DOMContentLoaded", dom_loaded_handler, {
                 capture: false,
             });
         }
@@ -380,7 +663,7 @@ const add_dom_loaded_handler = function () {
     }
 };
 /**
- * Initialize vTilt as a module (similar to PostHog's init_as_module)
+ * Initialize vTilt as a module
  * Returns an uninitialized vTilt instance that the user must call init() on
  */
 function init_as_module() {
@@ -389,7 +672,7 @@ function init_as_module() {
     return vTiltMain;
 }
 /**
- * Initialize vTilt from snippet (similar to PostHog's init_from_snippet)
+ * Initialize vTilt from snippet
  * Processes queued calls from the snippet stub and replaces it with real instance
  *
  * The snippet uses some clever tricks to allow deferred loading of array.js (this code)
@@ -451,7 +734,7 @@ function init_from_snippet() {
          *
          */
         // Call all pre-loaded init calls properly
-        (0, utils_1.each)(snippetVT["_i"], function (item) {
+        (0, utils_2.each)(snippetVT["_i"], function (item) {
             if (item && isArray(item)) {
                 const instance = vTiltMain.init(item[0], item[1], item[2]);
                 const instanceSnippet = snippetVT[item[2] || "vt"] || snippetVT;

package/lib/web-vitals.d.ts

@@ -1,9 +1,9 @@
 import { VTiltConfig } from "./types";
-import { TrackingManager } from "./tracking";
+import { VTilt } from "./vtilt";
 export declare class WebVitalsManager {
-    private trackingManager;
+    private instance;
     private webVitals;
-    constructor(config: VTiltConfig, trackingManager: TrackingManager);
+    constructor(config: VTiltConfig, instance: VTilt);
     /**
      * Initialize web vitals tracking
      */

package/lib/web-vitals.js

@@ -4,8 +4,8 @@ exports.WebVitalsManager = void 0;
 const geolocation_1 = require("./geolocation");
 const globals_1 = require("./utils/globals");
 class WebVitalsManager {
-    constructor(config, trackingManager) {
-        this.trackingManager = trackingManager;
+    constructor(config, instance) {
+        this.instance = instance;
         // Load web-vitals if enabled and in browser environment (not SSR)
         if (config.webVitals && globals_1.window) {
             try {
@@ -33,7 +33,7 @@ class WebVitalsManager {
                     return;
                 }
                 const { country, locale } = (0, geolocation_1.getCountryAndLocale)();
-                this.trackingManager.sendEvent("web_vital", {
+                this.instance.capture("web_vital", {
                     name: metric.name,
                     value: metric.value,
                     delta: metric.delta,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@v-tilt/browser",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "vTilt browser tracking library",
   "main": "dist/main.js",
   "module": "dist/module.js",
@@ -12,6 +12,15 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "build": "tsc -b && rollup -c",
+    "dev": "rollup -c -w",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "clean": "rimraf lib dist",
+    "prepublishOnly": "pnpm run build"
+  },
   "keywords": [
     "analytics",
     "tracking",
@@ -29,14 +38,14 @@
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^11.1.6",
     "@types/node": "^20.10.5",
+    "@v-tilt/eslint-config": "workspace:*",
     "eslint": "^9.0.0",
     "rimraf": "^5.0.5",
     "rollup": "^4.9.1",
     "rollup-plugin-dts": "^6.2.3",
     "rollup-plugin-terser": "^7.0.2",
     "rollup-plugin-visualizer": "^6.0.3",
-    "typescript": "^5.3.3",
-    "@v-tilt/eslint-config": "1.0.0"
+    "typescript": "^5.3.3"
   },
   "dependencies": {
     "web-vitals": "^3.5.0"
@@ -48,13 +57,5 @@
     "web-vitals": {
       "optional": true
     }
-  },
-  "scripts": {
-    "build": "tsc -b && rollup -c",
-    "dev": "rollup -c -w",
-    "type-check": "tsc --noEmit",
-    "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix",
-    "clean": "rimraf lib dist"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Tinybird.co
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.