@zaplier/sdk 1.7.9 → 1.8.1

package/dist/core-ultra.min.js

@@ -0,0 +1,10 @@
+/*!
+ * Zaplier SDK v2.0.0 - Ultra Minimal
+ * (c) 2025 Zaplier Team
+ */
+function e(){const e=document.createElement("canvas"),t=e.getContext("2d")
+t&&(t.textBaseline="top",t.font="14px Arial",t.fillText("Zaplier",2,2))
+const n=[navigator.userAgent,navigator.language,screen.width+"x"+screen.height,(new Date).getTimezoneOffset(),e.toDataURL(),navigator.hardwareConcurrency||0,navigator.maxTouchPoints||0]
+return btoa(n.join("|")).slice(0,32)}function t(e){return new n(e)}class n{constructor(t){this.config=t,this.visitorId=e(),this.sessionId=(()=>{const t=new Date,n=t.getFullYear()+(t.getMonth()+1+"").padStart(2,"0")+(t.getDate()+"").padStart(2,"0"),i=(t.getHours()+"").padStart(2,"0")
+return`${e()}_${n}_${i}`})(),this.track("page_view",{url:location.href,referrer:document.referrer})}track(e,t={}){(async(e,t)=>{try{await fetch(`${e.endpoint||"https://api.zaplier.com"}/events?token=${encodeURIComponent(e.token)}`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(t),keepalive:1})}catch(t){e.debug}})(this.config,{eventType:"page_view"===e?"page_view":"custom",eventName:e,sessionId:this.sessionId,visitorId:this.visitorId,timestamp:(new Date).toISOString(),...t})}getVisitor(){return{visitorId:this.visitorId,sessionId:this.sessionId}}}"undefined"!=typeof window&&(window.ZaplierMinimal={ZaplierMinimal:n,init:t})
+export{n as ZaplierMinimal,t as init}

package/dist/index.cjs

@@ -21386,7 +21386,7 @@ class ZaplierSDK {
         }
     }
     /**
-     * Initialize SDK
+     * Initialize SDK - Non-blocking approach
      */
     async initialize() {
         try {
@@ -21400,21 +21400,19 @@ class ZaplierSDK {
                 }
                 return;
             }
-            // Collect fingerprint
-            await this.collectFingerprint();
-            // Auto-track page view if enabled
+            // CRITICAL: Initialize basic tracking immediately (non-blocking)
+            this.isInitialized = true;
+            // Auto-track page view if enabled (immediate, before fingerprinting)
             if (this.config.autoTrack) {
                 this.trackPageView();
             }
-            this.isInitialized = true;
-            // Initialize anti-adblock system first
-            this.initializeAntiAdblock();
-            // Then initialize tracking engines (they'll connect to anti-adblock)
-            this.initializeTrackingEngines();
-            // Initialize auto tracker
-            this.initializeAutoTracker();
-            // Process queued events
+            // Process any queued events immediately
             this.processEventQueue();
+            // PERFORMANCE: Defer heavy operations to avoid blocking main thread
+            this.deferHeavyOperations();
+            if (this.config.debug) {
+                console.log("[Zaplier] Core SDK initialized (deferring heavy operations)");
+            }
             if (this.config.debug) {
                 console.log("[Zaplier] SDK initialized successfully", {
                     visitorId: this.visitorId,
@@ -21426,6 +21424,55 @@ class ZaplierSDK {
             console.error("[Zaplier] Initialization failed:", error);
         }
     }
+    /**
+     * Defer heavy operations to avoid blocking main thread
+     */
+    deferHeavyOperations() {
+        // Use requestIdleCallback for optimal performance, fallback to setTimeout
+        const scheduleWork = (callback, timeout = 5000) => {
+            if (typeof requestIdleCallback !== 'undefined') {
+                requestIdleCallback(callback, { timeout });
+            }
+            else {
+                setTimeout(callback, 100); // Small delay fallback
+            }
+        };
+        // Schedule fingerprinting when browser is idle
+        scheduleWork(async () => {
+            try {
+                await this.collectFingerprint();
+                if (this.config.debug) {
+                    console.log("[Zaplier] Fingerprint collected (deferred)");
+                }
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.error("[Zaplier] Deferred fingerprinting failed:", error);
+                }
+            }
+        }, 3000);
+        // Schedule anti-adblock initialization
+        scheduleWork(() => {
+            this.initializeAntiAdblock();
+            if (this.config.debug) {
+                console.log("[Zaplier] Anti-adblock initialized (deferred)");
+            }
+        }, 1000);
+        // Schedule tracking engines initialization
+        scheduleWork(() => {
+            this.initializeTrackingEngines();
+            if (this.config.debug) {
+                console.log("[Zaplier] Tracking engines initialized (deferred)");
+            }
+        }, 2000);
+        // Schedule auto tracker initialization  
+        scheduleWork(() => {
+            this.initializeAutoTracker();
+            if (this.config.debug) {
+                console.log("[Zaplier] Auto tracker initialized (deferred)");
+            }
+        }, 1500);
+    }
     /**
      * Initialize tracking engines (Session Replay & Heatmap)
      */

package/dist/index.d.ts

@@ -751,9 +751,13 @@ declare class ZaplierSDK implements ZaplierSDK$1 {
     private visitorIdentityManager?;
     constructor(userConfig: SDKConfig);
     /**
-     * Initialize SDK
+     * Initialize SDK - Non-blocking approach
      */
     private initialize;
+    /**
+     * Defer heavy operations to avoid blocking main thread
+     */
+    private deferHeavyOperations;
     /**
      * Initialize tracking engines (Session Replay & Heatmap)
      */

package/dist/index.esm.js

@@ -21382,7 +21382,7 @@ class ZaplierSDK {
         }
     }
     /**
-     * Initialize SDK
+     * Initialize SDK - Non-blocking approach
      */
     async initialize() {
         try {
@@ -21396,21 +21396,19 @@ class ZaplierSDK {
                 }
                 return;
             }
-            // Collect fingerprint
-            await this.collectFingerprint();
-            // Auto-track page view if enabled
+            // CRITICAL: Initialize basic tracking immediately (non-blocking)
+            this.isInitialized = true;
+            // Auto-track page view if enabled (immediate, before fingerprinting)
             if (this.config.autoTrack) {
                 this.trackPageView();
             }
-            this.isInitialized = true;
-            // Initialize anti-adblock system first
-            this.initializeAntiAdblock();
-            // Then initialize tracking engines (they'll connect to anti-adblock)
-            this.initializeTrackingEngines();
-            // Initialize auto tracker
-            this.initializeAutoTracker();
-            // Process queued events
+            // Process any queued events immediately
             this.processEventQueue();
+            // PERFORMANCE: Defer heavy operations to avoid blocking main thread
+            this.deferHeavyOperations();
+            if (this.config.debug) {
+                console.log("[Zaplier] Core SDK initialized (deferring heavy operations)");
+            }
             if (this.config.debug) {
                 console.log("[Zaplier] SDK initialized successfully", {
                     visitorId: this.visitorId,
@@ -21422,6 +21420,55 @@ class ZaplierSDK {
             console.error("[Zaplier] Initialization failed:", error);
         }
     }
+    /**
+     * Defer heavy operations to avoid blocking main thread
+     */
+    deferHeavyOperations() {
+        // Use requestIdleCallback for optimal performance, fallback to setTimeout
+        const scheduleWork = (callback, timeout = 5000) => {
+            if (typeof requestIdleCallback !== 'undefined') {
+                requestIdleCallback(callback, { timeout });
+            }
+            else {
+                setTimeout(callback, 100); // Small delay fallback
+            }
+        };
+        // Schedule fingerprinting when browser is idle
+        scheduleWork(async () => {
+            try {
+                await this.collectFingerprint();
+                if (this.config.debug) {
+                    console.log("[Zaplier] Fingerprint collected (deferred)");
+                }
+            }
+            catch (error) {
+                if (this.config.debug) {
+                    console.error("[Zaplier] Deferred fingerprinting failed:", error);
+                }
+            }
+        }, 3000);
+        // Schedule anti-adblock initialization
+        scheduleWork(() => {
+            this.initializeAntiAdblock();
+            if (this.config.debug) {
+                console.log("[Zaplier] Anti-adblock initialized (deferred)");
+            }
+        }, 1000);
+        // Schedule tracking engines initialization
+        scheduleWork(() => {
+            this.initializeTrackingEngines();
+            if (this.config.debug) {
+                console.log("[Zaplier] Tracking engines initialized (deferred)");
+            }
+        }, 2000);
+        // Schedule auto tracker initialization  
+        scheduleWork(() => {
+            this.initializeAutoTracker();
+            if (this.config.debug) {
+                console.log("[Zaplier] Auto tracker initialized (deferred)");
+            }
+        }, 1500);
+    }
     /**
      * Initialize tracking engines (Session Replay & Heatmap)
      */

package/dist/v2/core.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Zaplier SDK Core v2.0.0 - Performance Optimized
+ * Minimal core for instant initialization with lazy loading
+ */
+interface CoreConfig {
+    token: string;
+    debug?: boolean;
+    apiEndpoint?: string;
+    allow_localhost?: boolean;
+    replay?: boolean;
+    replaySampling?: number;
+    deferAdvanced?: boolean;
+    loadTimeout?: number;
+}
+/**
+ * Minimal SDK Core - Only essential tracking functionality
+ * Heavy operations are lazy-loaded to avoid blocking main thread
+ */
+declare class ZaplierCore {
+    private config;
+    private eventQueue;
+    private isInitialized;
+    private sessionId?;
+    private visitorId?;
+    private modules;
+    private readonly version;
+    constructor(config: CoreConfig);
+    /**
+     * Instant core initialization - only essential setup
+     */
+    private initializeCore;
+    /**
+     * Track page view immediately (core functionality)
+     */
+    trackPageView(data?: any): void;
+    /**
+     * Track custom event immediately
+     */
+    track(eventName: string, data?: any): void;
+    /**
+     * Enable advanced features (lazy loading)
+     */
+    enableAdvancedFeatures(): Promise<void>;
+    /**
+     * Load fingerprinting module
+     */
+    private loadFingerprinting;
+    /**
+     * Load replay module
+     */
+    private loadReplayModule;
+    /**
+     * Schedule advanced loading when browser is idle
+     */
+    private scheduleAdvancedLoading;
+    /**
+     * Send event to backend (simplified)
+     */
+    private sendEvent;
+    /**
+     * Process queued events
+     */
+    private processEventQueue;
+    /**
+     * Generate temporary session ID
+     */
+    private generateTempSessionId;
+    /**
+     * Generate temporary visitor ID
+     */
+    private generateTempVisitorId;
+    /**
+     * Get visitor info (for compatibility)
+     */
+    getVisitorInfo(): {
+        visitorId: string | undefined;
+        sessionId: string | undefined;
+        isReady: boolean;
+        hasFingerprint: boolean;
+    };
+}
+/**
+ * Factory function for easy initialization
+ */
+declare function initZaplierCore(config: CoreConfig): ZaplierCore;
+
+export { ZaplierCore, ZaplierCore as default, initZaplierCore };
+export type { CoreConfig };

package/dist/v2/core.js

@@ -0,0 +1,245 @@
+/*!
+ * Zaplier SDK v2.0.0 - Performance Optimized
+ * Advanced privacy-first tracking with code splitting
+ * (c) 2025 Zaplier Team
+ */
+/**
+ * Zaplier SDK Core v2.0.0 - Performance Optimized
+ * Minimal core for instant initialization with lazy loading
+ */
+/**
+ * Minimal SDK Core - Only essential tracking functionality
+ * Heavy operations are lazy-loaded to avoid blocking main thread
+ */
+class ZaplierCore {
+    constructor(config) {
+        this.eventQueue = [];
+        this.isInitialized = false;
+        this.modules = new Map();
+        this.version = "2.0.0";
+        this.config = {
+            deferAdvanced: true,
+            loadTimeout: 5000,
+            debug: false,
+            ...config
+        };
+        // Immediate initialization (< 1ms)
+        this.initializeCore();
+    }
+    /**
+     * Instant core initialization - only essential setup
+     */
+    initializeCore() {
+        try {
+            if (this.config.debug) {
+                console.log(`[Zaplier Core] v${this.version} initializing...`);
+            }
+            // Generate temporary IDs immediately
+            this.sessionId = this.generateTempSessionId();
+            this.visitorId = this.generateTempVisitorId();
+            this.isInitialized = true;
+            // Process any queued events
+            this.processEventQueue();
+            if (this.config.debug) {
+                console.log(`[Zaplier Core] Initialized in < 1ms (modules will load lazily)`);
+            }
+            // Schedule advanced features if not deferred
+            if (!this.config.deferAdvanced) {
+                this.scheduleAdvancedLoading();
+            }
+        }
+        catch (error) {
+            console.error("[Zaplier Core] Initialization failed:", error);
+        }
+    }
+    /**
+     * Track page view immediately (core functionality)
+     */
+    trackPageView(data = {}) {
+        if (this.config.debug) {
+            console.log("[Zaplier Core] Tracking page view (immediate)");
+        }
+        const event = {
+            eventType: 'page_view',
+            eventName: 'page_view',
+            sessionId: this.sessionId,
+            visitorId: this.visitorId,
+            url: window.location.href,
+            referrer: document.referrer,
+            timestamp: new Date().toISOString(),
+            ...data
+        };
+        // Send immediately without heavy processing
+        this.sendEvent(event);
+    }
+    /**
+     * Track custom event immediately
+     */
+    track(eventName, data = {}) {
+        if (this.config.debug) {
+            console.log(`[Zaplier Core] Tracking event: ${eventName}`);
+        }
+        const event = {
+            eventType: 'custom',
+            eventName,
+            sessionId: this.sessionId,
+            visitorId: this.visitorId,
+            timestamp: new Date().toISOString(),
+            ...data
+        };
+        this.sendEvent(event);
+    }
+    /**
+     * Enable advanced features (lazy loading)
+     */
+    async enableAdvancedFeatures() {
+        if (this.config.debug) {
+            console.log("[Zaplier Core] Loading advanced features...");
+        }
+        try {
+            // Load fingerprinting
+            await this.loadFingerprinting();
+            // Load other modules based on config
+            if (this.config.replay) {
+                await this.loadReplayModule();
+            }
+            // Add other modules as needed
+            if (this.config.debug) {
+                console.log("[Zaplier Core] Advanced features loaded");
+            }
+        }
+        catch (error) {
+            console.error("[Zaplier Core] Failed to load advanced features:", error);
+        }
+    }
+    /**
+     * Load fingerprinting module
+     */
+    async loadFingerprinting() {
+        if (this.modules.has('fingerprint'))
+            return;
+        try {
+            const { getCompleteFingerprint } = await import('./chunks/fingerprint-BpVzoJ8I.js');
+            const fingerprint = await getCompleteFingerprint();
+            if (fingerprint.success && fingerprint.data) {
+                // Update visitor ID with real fingerprint hash
+                this.visitorId = fingerprint.data.hash || this.visitorId;
+                this.modules.set('fingerprint', fingerprint.data);
+                if (this.config.debug) {
+                    console.log("[Zaplier Core] Fingerprinting loaded");
+                }
+            }
+        }
+        catch (error) {
+            console.error("[Zaplier Core] Fingerprinting failed:", error);
+        }
+    }
+    /**
+     * Load replay module
+     */
+    async loadReplayModule() {
+        if (this.modules.has('replay'))
+            return;
+        try {
+            const { SessionReplayEngine } = await import('./chunks/session-replay-_79DdSl3.js');
+            const replayEngine = new SessionReplayEngine(this.sessionId, this.visitorId, {
+                sampleRate: this.config.replaySampling || 0.1,
+            });
+            if (replayEngine.start()) {
+                this.modules.set('replay', replayEngine);
+                if (this.config.debug) {
+                    console.log("[Zaplier Core] Session replay loaded");
+                }
+            }
+        }
+        catch (error) {
+            console.error("[Zaplier Core] Replay loading failed:", error);
+        }
+    }
+    /**
+     * Schedule advanced loading when browser is idle
+     */
+    scheduleAdvancedLoading() {
+        const scheduleWork = (callback, delay = 100) => {
+            if (typeof requestIdleCallback !== 'undefined') {
+                requestIdleCallback(callback, { timeout: this.config.loadTimeout });
+            }
+            else {
+                setTimeout(callback, delay);
+            }
+        };
+        scheduleWork(() => this.enableAdvancedFeatures());
+    }
+    /**
+     * Send event to backend (simplified)
+     */
+    async sendEvent(event) {
+        try {
+            // Simple fetch without heavy processing
+            const response = await fetch(`${this.config.apiEndpoint || 'https://api.zaplier.com'}/events?token=${encodeURIComponent(this.config.token)}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(event),
+                keepalive: true, // Important for page unload events
+            });
+            if (this.config.debug && !response.ok) {
+                console.warn(`[Zaplier Core] Event sending failed: ${response.status}`);
+            }
+        }
+        catch (error) {
+            // Queue for retry if needed
+            this.eventQueue.push(event);
+            if (this.config.debug) {
+                console.warn("[Zaplier Core] Event queued for retry:", error);
+            }
+        }
+    }
+    /**
+     * Process queued events
+     */
+    processEventQueue() {
+        if (this.eventQueue.length === 0)
+            return;
+        const events = [...this.eventQueue];
+        this.eventQueue = [];
+        events.forEach(event => this.sendEvent(event));
+    }
+    /**
+     * Generate temporary session ID
+     */
+    generateTempSessionId() {
+        const now = new Date();
+        const dateStr = now.getFullYear() +
+            (now.getMonth() + 1).toString().padStart(2, '0') +
+            now.getDate().toString().padStart(2, '0');
+        const hour = now.getHours().toString().padStart(2, '0');
+        return `temp_${Date.now()}_${dateStr}_${hour}`;
+    }
+    /**
+     * Generate temporary visitor ID
+     */
+    generateTempVisitorId() {
+        return `temp_visitor_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Get visitor info (for compatibility)
+     */
+    getVisitorInfo() {
+        return {
+            visitorId: this.visitorId,
+            sessionId: this.sessionId,
+            isReady: this.isInitialized,
+            hasFingerprint: this.modules.has('fingerprint'),
+        };
+    }
+}
+/**
+ * Factory function for easy initialization
+ */
+function initZaplierCore(config) {
+    return new ZaplierCore(config);
+}
+
+export { ZaplierCore, ZaplierCore as default, initZaplierCore };