@zaplier/sdk 1.1.8 → 1.2.0

package/dist/sdk.js

@@ -6153,112 +6153,6 @@
             }
         }
     }
-    /**
-     * 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)
      */
@@ -6321,6 +6215,112 @@
             }
         }
     }
+    /**
+     * 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)
      */
@@ -6331,7 +6331,7 @@
             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' };
@@ -6382,12 +6382,14 @@
                 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;
@@ -6422,7 +6424,7 @@
             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' };
@@ -6494,7 +6496,7 @@
      * Main Anti-Adblock Manager
      */
     class AntiAdblockManager {
-        constructor(baseUrl, config = {}) {
+        constructor(baseUrl, token, config = {}) {
             this.transports = [];
             this.stats = {
                 totalRequests: 0,
@@ -6503,9 +6505,10 @@
                 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,
@@ -6515,9 +6518,9 @@
         }
         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()
             };
@@ -7761,9 +7764,10 @@
          */
         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,