@zaplier/sdk 1.1.8 → 1.2.0

package/dist/index.esm.js

@@ -6147,112 +6147,6 @@ class FetchTransport {
         }
     }
 }
-/**
- * WebSocket Transport
- */
-class WebSocketTransport {
-    constructor(baseUrl) {
-        this.name = 'websocket';
-        this.available = typeof WebSocket !== 'undefined';
-        this.connected = false;
-        this.messageQueue = [];
-        this.baseUrl = baseUrl.replace(/^http/, 'ws');
-    }
-    async connect() {
-        if (this.connected || !this.available)
-            return;
-        return new Promise((resolve, reject) => {
-            try {
-                this.ws = new WebSocket(`${this.baseUrl}/ws/track`);
-                this.ws.onopen = () => {
-                    this.connected = true;
-                    this.processQueue();
-                    resolve();
-                };
-                this.ws.onerror = () => {
-                    reject(new Error('WebSocket connection failed'));
-                };
-                this.ws.onclose = () => {
-                    this.connected = false;
-                    // Try to reconnect after 5 seconds
-                    setTimeout(() => this.connect().catch(() => { }), 5000);
-                };
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    processQueue() {
-        while (this.messageQueue.length > 0 && this.connected) {
-            const item = this.messageQueue.shift();
-            if (item && this.ws) {
-                try {
-                    this.ws.send(JSON.stringify(item.data));
-                    item.resolve({ success: true, method: this.name });
-                }
-                catch (error) {
-                    item.resolve({
-                        success: false,
-                        method: this.name,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-        }
-    }
-    async send(data, endpoint) {
-        const start = Date.now();
-        if (!this.available) {
-            return { success: false, method: this.name, error: 'WebSocket not available' };
-        }
-        // Try to connect if not connected
-        if (!this.connected) {
-            try {
-                await this.connect();
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    method: this.name,
-                    error: error instanceof Error ? error.message : String(error)
-                };
-            }
-        }
-        return new Promise((resolve) => {
-            if (this.connected && this.ws) {
-                try {
-                    this.ws.send(JSON.stringify(data));
-                    resolve({
-                        success: true,
-                        method: this.name,
-                        latency: Date.now() - start
-                    });
-                }
-                catch (error) {
-                    resolve({
-                        success: false,
-                        method: this.name,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            else {
-                // Queue message for later
-                this.messageQueue.push({ data, resolve: (response) => resolve({
-                        ...response,
-                        latency: Date.now() - start
-                    }) });
-            }
-        });
-    }
-    destroy() {
-        if (this.ws) {
-            this.ws.close();
-            this.connected = false;
-        }
-    }
-}
 /**
  * Resource Spoofing Transport (GET requests disguised as assets)
  */
@@ -6315,6 +6209,112 @@ class ResourceSpoofTransport {
         }
     }
 }
+/**
+ * Elysia WebSocket Transport (Native WebSocket for anti-adblock)
+ */
+class ElysiaWebSocketTransport {
+    constructor(baseUrl, token) {
+        this.name = 'elysia-websocket';
+        this.available = typeof WebSocket !== 'undefined';
+        this.connected = false;
+        this.baseUrl = baseUrl;
+        this.token = token;
+    }
+    async send(data, endpoint) {
+        const start = Date.now();
+        try {
+            if (!this.token) {
+                throw new Error('Missing token for WebSocket connection');
+            }
+            await this.connect();
+            if (!this.ws || !this.connected) {
+                throw new Error('WebSocket not connected');
+            }
+            return new Promise((resolve, reject) => {
+                const messageHandler = (event) => {
+                    try {
+                        const response = JSON.parse(event.data);
+                        this.ws?.removeEventListener('message', messageHandler);
+                        resolve({
+                            success: response.success || false,
+                            method: this.name,
+                            latency: Date.now() - start
+                        });
+                    }
+                    catch (error) {
+                        this.ws?.removeEventListener('message', messageHandler);
+                        reject(new Error('Failed to parse WebSocket response'));
+                    }
+                };
+                this.ws?.addEventListener('message', messageHandler);
+                // Send the tracking data
+                this.ws?.send(JSON.stringify({
+                    eventId: data.eventId || crypto.randomUUID(),
+                    sessionId: data.sessionId || data.s,
+                    eventType: data.eventType || data.type || 'websocket_event',
+                    eventName: data.eventName || data.name,
+                    url: data.url,
+                    userAgent: data.userAgent || navigator.userAgent,
+                    timestamp: new Date().toISOString()
+                }));
+                // Timeout after 5 seconds
+                setTimeout(() => {
+                    this.ws?.removeEventListener('message', messageHandler);
+                    reject(new Error('WebSocket response timeout'));
+                }, 5000);
+            });
+        }
+        catch (error) {
+            return {
+                success: false,
+                method: this.name,
+                latency: Date.now() - start,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async connect() {
+        if (this.connected && this.ws?.readyState === WebSocket.OPEN) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                // Convert HTTP/HTTPS to WS/WSS
+                const url = new URL(this.baseUrl);
+                const protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+                const wsUrl = `${protocol}//${url.host}/ws/track?token=${encodeURIComponent(this.token)}`;
+                this.ws = new WebSocket(wsUrl);
+                this.ws.onopen = () => {
+                    this.connected = true;
+                    resolve();
+                };
+                this.ws.onerror = () => {
+                    this.connected = false;
+                    reject(new Error('WebSocket connection failed'));
+                };
+                this.ws.onclose = () => {
+                    this.connected = false;
+                };
+                // Timeout after 5 seconds
+                setTimeout(() => {
+                    if (!this.connected) {
+                        this.ws?.close();
+                        reject(new Error('WebSocket connection timeout'));
+                    }
+                }, 5000);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    cleanup() {
+        if (this.ws) {
+            this.ws.close();
+            this.connected = false;
+        }
+    }
+}
 /**
  * Socket.io Transport (Real-time bidirectional communication for anti-adblock)
  */
@@ -6325,7 +6325,7 @@ class SocketIOTransport {
         this.connected = false;
         this.baseUrl = baseUrl;
     }
-    async send(data, endpoint) {
+    async send(data, _endpoint) {
         const start = Date.now();
         if (!this.available) {
             return { success: false, method: this.name, error: 'WebRTC not available' };
@@ -6376,12 +6376,14 @@ class SocketIOTransport {
             try {
                 // Use dynamic import to load socket.io-client only when needed
                 Promise.resolve().then(function () { return index; }).then(({ io }) => {
-                    // Extract domain from baseUrl - use HTTP for Socket.io connection
+                    // Extract domain from baseUrl - preserve protocol (HTTP/HTTPS)
                     const url = new URL(this.baseUrl);
-                    const socketUrl = `http://${url.host}`;
+                    const socketUrl = `${url.protocol}//${url.host}`;
                     this.socket = io(socketUrl, {
-                        transports: ['websocket', 'polling'],
-                        timeout: 5000
+                        transports: ['polling', 'websocket'], // Try polling first for better proxy compatibility
+                        timeout: 5000,
+                        upgrade: true,
+                        rememberUpgrade: false
                     });
                     this.socket.on('connect', () => {
                         this.connected = true;
@@ -6416,7 +6418,7 @@ class WebRTCTransport {
         this.available = typeof globalThis.RTCPeerConnection !== 'undefined';
         this.connected = false;
     }
-    async send(data, endpoint) {
+    async send(data, _endpoint) {
         const start = Date.now();
         if (!this.available) {
             return { success: false, method: this.name, error: 'WebRTC not available' };
@@ -6488,7 +6490,7 @@ class WebRTCTransport {
  * Main Anti-Adblock Manager
  */
 class AntiAdblockManager {
-    constructor(baseUrl, config = {}) {
+    constructor(baseUrl, token, config = {}) {
         this.transports = [];
         this.stats = {
             totalRequests: 0,
@@ -6497,9 +6499,10 @@ class AntiAdblockManager {
             methodFailures: new Map()
         };
         this.baseUrl = baseUrl;
+        this.token = token;
         this.config = {
             enabled: true,
-            methods: ['socketio', 'fetch', 'resource'], // Socket.io as primary, removed native websocket
+            methods: ['elysia-websocket', 'fetch', 'resource'], // Elysia WebSocket as primary
             fallbackDelay: 100,
             maxRetries: 2,
             debug: false,
@@ -6509,9 +6512,9 @@ class AntiAdblockManager {
     }
     initializeTransports() {
         const transportMap = {
+            'elysia-websocket': () => new ElysiaWebSocketTransport(this.baseUrl, this.token),
             socketio: () => new SocketIOTransport(this.baseUrl),
             fetch: () => new FetchTransport(),
-            websocket: () => new WebSocketTransport(this.baseUrl),
             resource: () => new ResourceSpoofTransport(this.baseUrl),
             webrtc: () => new WebRTCTransport()
         };
@@ -7755,9 +7758,10 @@ class ZaplierSDK {
      */
     initializeAntiAdblock() {
         try {
-            this.antiAdblockManager = new AntiAdblockManager(this.config.apiEndpoint, {
+            this.antiAdblockManager = new AntiAdblockManager(this.config.apiEndpoint, this.config.token, // Pass token to anti-adblock manager
+            {
                 enabled: true,
-                methods: ["socketio", "fetch", "resource"], // Socket.io as primary, removed native websocket
+                methods: ["elysia-websocket", "fetch", "resource"], // Elysia WebSocket as primary
                 fallbackDelay: 100,
                 maxRetries: 2,
                 debug: this.config.debug,