@v-tilt/browser 1.0.1

package/dist/vtilt.d.ts

@@ -0,0 +1,178 @@
+import { VTiltConfig, EventPayload } from "./types";
+export declare class VTilt {
+    private configManager;
+    private trackingManager;
+    private webVitalsManager;
+    private initialized;
+    constructor(config?: Partial<VTiltConfig>);
+    /**
+     * Initialize VTilt tracking
+     */
+    init(): void;
+    /**
+     * Track a custom event
+     */
+    trackEvent(name: string, payload?: EventPayload): void;
+    /**
+     * Identify a user with PostHog-style property operations
+     * Copied from PostHog's identify method signature
+     *
+     * @example
+     * ```js
+     * // Basic identify with properties
+     * vTilt.identify('user_123',
+     *   { name: 'John Doe', email: 'john@example.com' },  // $set properties
+     *   { first_login: new Date().toISOString() }         // $set_once properties
+     * )
+     * ```
+     *
+     * @example
+     * ```js
+     * // If no $set is provided, all properties are treated as $set
+     * vTilt.identify('user_123', { name: 'John Doe', email: 'john@example.com' })
+     * ```
+     */
+    identify(distinctId?: string, userPropertiesToSet?: Record<string, any>, userPropertiesToSetOnce?: Record<string, any>): void;
+    /**
+     * Set user properties with PostHog-style operations
+     * Sets properties on the person profile associated with the current distinct_id
+     *
+     * @example
+     * ```js
+     * // Set properties that can be updated
+     * vTilt.setUserProperties({ name: 'John Doe', email: 'john@example.com' })
+     * ```
+     *
+     * @example
+     * ```js
+     * // Set properties with $set and $set_once operations
+     * vTilt.setUserProperties(
+     *   { name: 'John Doe', last_login: new Date().toISOString() },  // $set properties
+     *   { first_login: new Date().toISOString() }                     // $set_once properties
+     * )
+     * ```
+     *
+     * @param userPropertiesToSet Optional: Properties to set (can be updated)
+     * @param userPropertiesToSetOnce Optional: Properties to set once (preserves first value)
+     */
+    setUserProperties(userPropertiesToSet?: Record<string, any>, userPropertiesToSetOnce?: Record<string, any>): void;
+    /**
+     * Reset user identity (logout)
+     * PostHog behavior: Clears all user data, generates new anonymous ID
+     *
+     * @param reset_device_id - If true, also resets device_id. Default: false
+     *
+     * @example
+     * // Reset on user logout
+     * vtilt.resetUser()
+     *
+     * @example
+     * // Reset and generate new device ID
+     * vtilt.resetUser(true)
+     */
+    resetUser(reset_device_id?: boolean): void;
+    /**
+     * Get current user identity
+     */
+    getUserIdentity(): import("./types").UserIdentity;
+    /**
+     * Get current device ID
+     */
+    getDeviceId(): string;
+    /**
+     * Get current user state
+     */
+    getUserState(): "anonymous" | "identified";
+    /**
+     * Create an alias to link two distinct IDs
+     * PostHog behavior: 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)
+     *
+     * @example
+     * // Link anonymous user to account on signup
+     * vtilt.createAlias('user_12345')
+     *
+     * @example
+     * // Explicit alias with original ID
+     * vtilt.createAlias('user_12345', 'anonymous_abc123')
+     */
+    createAlias(alias: string, original?: string): void;
+    /**
+     * Setup page tracking with history API support
+     */
+    private setupPageTracking;
+    /**
+     * Track page hit
+     */
+    private trackPageHit;
+    /**
+     * Setup visibility change tracking for prerendered pages
+     */
+    private setupVisibilityTracking;
+    /**
+     * Get current configuration
+     */
+    getConfig(): VTiltConfig;
+    /**
+     * Get current session ID
+     */
+    getSessionId(): string | null;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<VTiltConfig>): void;
+    /**
+     * _execute_array() deals with processing any VTilt function
+     * calls that were called before the VTilt library was loaded
+     * (and are thus stored in an array so they can be called later)
+     *
+     * Note: we fire off all the VTilt function calls BEFORE we fire off
+     * tracking calls. This is so identify/setUserProperties/updateConfig calls
+     * can properly modify early tracking calls.
+     *
+     * @param {Array} array Array of queued calls in format [methodName, ...args]
+     */
+    _execute_array(array: any[]): void;
+    /**
+     * Called when DOM is loaded - processes queued requests
+     */
+    _dom_loaded(): void;
+}
+/**
+ * Initialize VTilt as a module (similar to PostHog's init_as_module)
+ * Returns an uninitialized VTilt instance that the user must call init() on
+ */
+export declare function init_as_module(): VTilt;
+/**
+ * Initialize VTilt from snippet (similar to PostHog's init_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)
+ *
+ * window.vt is an array which the queue of calls made before the lib is loaded
+ * It has methods attached to it to simulate the vt object so for instance
+ *
+ * window.vt.init("projectId", {token: "token", host: "host"})
+ * window.vt.trackEvent("my-event", {foo: "bar"})
+ *
+ * ... will mean that window.vt will look like this:
+ * window.vt == [
+ *   ["trackEvent", "my-event", {foo: "bar"}]
+ * ]
+ *
+ * window.vt._i == [
+ *   ["projectId", {token: "token", host: "host"}, "vt"]
+ * ]
+ *
+ * If a name is given to the init function then the same as above is true but as a sub-property on the object:
+ *
+ * window.vt.init("projectId", {token: "token"}, "vt2")
+ * window.vt.vt2.trackEvent("my-event", {foo: "bar"})
+ *
+ * window.vt.vt2 == [
+ *   ["trackEvent", "my-event", {foo: "bar"}]
+ * ]
+ */
+export declare function init_from_snippet(): void;

package/dist/web-vitals.d.ts

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

package/lib/config.d.ts

@@ -0,0 +1,17 @@
+import { VTiltConfig } from "./types";
+export declare class ConfigManager {
+    private config;
+    constructor(config?: Partial<VTiltConfig>);
+    /**
+     * Parse configuration from script attributes
+     */
+    private parseConfigFromScript;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): VTiltConfig;
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig: Partial<VTiltConfig>): void;
+}

package/lib/config.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+class ConfigManager {
+    constructor(config = {}) {
+        this.config = this.parseConfigFromScript(config);
+    }
+    /**
+     * Parse configuration from script attributes
+     */
+    parseConfigFromScript(initialConfig) {
+        if (!document.currentScript) {
+            return {
+                projectId: initialConfig.projectId || "",
+                token: initialConfig.token || "",
+                ...initialConfig,
+            };
+        }
+        const script = document.currentScript;
+        const config = {
+            projectId: "", // Required field with default
+            token: "", // Required field with default
+            ...initialConfig,
+        };
+        // Parse basic attributes
+        config.host = script.getAttribute("data-host") || initialConfig.host;
+        config.proxy = script.getAttribute("data-proxy") || initialConfig.proxy;
+        config.proxyUrl =
+            script.getAttribute("data-proxy-url") || initialConfig.proxyUrl;
+        config.token =
+            script.getAttribute("data-token") || initialConfig.token || "";
+        config.projectId =
+            script.getAttribute("data-project-id") || initialConfig.projectId || "";
+        config.domain = script.getAttribute("data-domain") || initialConfig.domain;
+        config.storage =
+            script.getAttribute("data-storage") || initialConfig.storage;
+        config.stringifyPayload =
+            script.getAttribute("data-stringify-payload") !== "false";
+        config.webVitals =
+            script.getAttribute("web-vitals") === "true" ||
+                script.getAttribute("data-web-vitals") === "true" ||
+                initialConfig.webVitals;
+        // Check for conflicting proxy configurations
+        if (config.proxy && config.proxyUrl) {
+            console.error("Error: Both data-proxy and data-proxy-url are specified. Please use only one of them.");
+            throw new Error("Both data-proxy and data-proxy-url are specified. Please use only one of them.");
+        }
+        // Parse global attributes
+        config.globalAttributes = { ...initialConfig.globalAttributes };
+        // NamedNodeMap is not iterable, so use Array.from to iterate over attributes
+        for (const attr of Array.from(script.attributes)) {
+            if (attr.name.startsWith("tb_")) {
+                config.globalAttributes[attr.name.slice(3).replace(/-/g, "_")] =
+                    attr.value;
+            }
+            if (attr.name.startsWith("data-tb-")) {
+                config.globalAttributes[attr.name.slice(8).replace(/-/g, "_")] =
+                    attr.value;
+            }
+        }
+        return config;
+    }
+    /**
+     * Get the current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+    }
+}
+exports.ConfigManager = ConfigManager;

package/lib/constants.d.ts

@@ -0,0 +1,10 @@
+import { StorageMethods } from "./types";
+export declare const STORAGE_KEY = "vt_session_id";
+export declare const ANONYMOUS_ID_KEY = "vt_anonymous_id";
+export declare const DISTINCT_ID_KEY = "vt_distinct_id";
+export declare const DEVICE_ID_KEY = "vt_device_id";
+export declare const USER_PROPERTIES_KEY = "vt_user_properties";
+export declare const USER_STATE_KEY = "vt_user_state";
+export declare const STORAGE_METHODS: StorageMethods;
+export declare const TIMEZONES: Record<string, string>;
+export declare const ATTRIBUTES_TO_MASK: string[];