@leanbase-giangnd/js 0.0.2 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leanbase-giangnd/js",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Leanbase browser SDK - event tracking, autocapture, and session replay",
   "repository": {
     "type": "git",

package/src/leanbase.ts

@@ -32,6 +32,7 @@ import {
     navigator,
     userAgent,
 } from './utils'
+import { decompressSync, strFromU8 } from 'fflate'
 import Config from './config'
 import { Autocapture } from './autocapture'
 import { logger } from './leanbase-logger'
@@ -209,11 +210,12 @@ export class Leanbase extends PostHogCore {
         this.sessionRecording?.onRemoteConfig(config)
     }
 
-    fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse> {
+    async fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse> {
         const fetchFn = getFetch()
         if (!fetchFn) {
-            return Promise.reject(new Error('Fetch API is not available in this environment.'))
+            throw new Error('Fetch API is not available in this environment.')
         }
+
         try {
             const isPost = !options.method || options.method.toUpperCase() === 'POST'
             const isBatchEndpoint = typeof url === 'string' && url.endsWith('/batch/')
@@ -221,17 +223,83 @@ export class Leanbase extends PostHogCore {
             if (isPost && isBatchEndpoint && options && options.body) {
                 let parsed: any = null
                 try {
-                    const bodyString = typeof options.body === 'string' ? options.body : String(options.body)
-                    parsed = JSON.parse(bodyString)
+                    const headers = (options.headers || {}) as Record<string, any>
+                    const contentEncoding = (
+                        headers['Content-Encoding'] ||
+                        headers['content-encoding'] ||
+                        ''
+                    ).toLowerCase()
+
+                    const toUint8 = async (body: any): Promise<Uint8Array | null> => {
+                        if (typeof body === 'string') return new TextEncoder().encode(body)
+                        if (typeof Blob !== 'undefined' && body instanceof Blob) {
+                            const ab = await body.arrayBuffer()
+                            return new Uint8Array(ab)
+                        }
+                        if (body instanceof ArrayBuffer) return new Uint8Array(body)
+                        if (ArrayBuffer.isView(body)) return new Uint8Array((body as any).buffer ?? body)
+                        try {
+                            return new TextEncoder().encode(String(body))
+                        } catch {
+                            return null
+                        }
+                    }
+
+                    if (contentEncoding === 'gzip' || contentEncoding === 'deflate') {
+                        const u8 = await toUint8(options.body)
+                        if (u8) {
+                            try {
+                                const dec = decompressSync(u8)
+                                const s = strFromU8(dec)
+                                parsed = JSON.parse(s)
+                            } catch {
+                                parsed = null
+                            }
+                        }
+                    } else {
+                        if (typeof options.body === 'string') {
+                            parsed = JSON.parse(options.body)
+                        } else {
+                            const u8 = await toUint8(options.body)
+                            if (u8) {
+                                try {
+                                    parsed = JSON.parse(new TextDecoder().decode(u8))
+                                } catch {
+                                    parsed = null
+                                }
+                            } else {
+                                try {
+                                    parsed = JSON.parse(String(options.body))
+                                } catch {
+                                    parsed = null
+                                }
+                            }
+                        }
+                    }
                 } catch {
                     parsed = null
                 }
 
                 if (parsed && isArray(parsed.batch)) {
                     const hasSnapshot = parsed.batch.some((item: any) => item && item.event === '$snapshot')
+                    // Debug logging to help diagnose routing issues
+                    try {
+                        // eslint-disable-next-line no-console
+                        console.debug(
+                            '[Leanbase.fetch] parsed.batch.length=',
+                            parsed.batch.length,
+                            'hasSnapshot=',
+                            hasSnapshot
+                        )
+                    } catch {}
+
                     if (hasSnapshot) {
                         const host = (this.config && this.config.host) || ''
                         const newUrl = host ? `${host.replace(/\/$/, '')}/s/` : url
+                        try {
+                            // eslint-disable-next-line no-console
+                            console.debug('[Leanbase.fetch] routing snapshot batch to', newUrl)
+                        } catch {}
                         return fetchFn(newUrl, options)
                     }
                 }

package/src/types/fflate.d.ts

@@ -1,5 +1,6 @@
 declare module 'fflate' {
     export const gzipSync: (...args: any[]) => any
     export const strFromU8: (...args: any[]) => any
+    export const decompressSync: (...args: any[]) => any
     export const strToU8: (...args: any[]) => any
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = '0.0.2'
+export const version = '0.0.3'