@leanbase-giangnd/js 0.0.2 → 0.0.4

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 var core = require('@posthog/core');
-var record = require('@rrweb/record');
 var fflate = require('fflate');
+var record = require('@rrweb/record');
 
 const breaker = {};
 const ArrayProto = Array.prototype;
@@ -1185,7 +1185,7 @@ const detectDeviceType = function (user_agent) {
   }
 };
 
-var version = "0.0.2";
+var version = "0.0.4";
 var packageInfo = {
 	version: version};
 
@@ -5817,10 +5817,10 @@ class Leanbase extends core.PostHogCore {
     this.replayAutocapture?.onRemoteConfig(config);
     this.sessionRecording?.onRemoteConfig(config);
   }
-  fetch(url, options) {
+  async fetch(url, options) {
     const fetchFn = core.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';
@@ -5828,16 +5828,99 @@ class Leanbase extends core.PostHogCore {
       if (isPost && isBatchEndpoint && options && options.body) {
         let parsed = null;
         try {
-          const bodyString = typeof options.body === 'string' ? options.body : String(options.body);
-          parsed = JSON.parse(bodyString);
+          const headers = options.headers || {};
+          const contentEncoding = (headers['Content-Encoding'] || headers['content-encoding'] || '').toLowerCase();
+          const toUint8 = async body => {
+            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.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 = fflate.decompressSync(u8);
+                const s = fflate.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 && core.isArray(parsed.batch)) {
           const hasSnapshot = parsed.batch.some(item => 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 remote config has explicitly disabled session recording, drop snapshot events
+          try {
+            // Read persisted remote config that SessionRecording stores
+            const persisted = this.get_property(SESSION_RECORDING_REMOTE_CONFIG);
+            const serverAllowsRecording = !(persisted && persisted.enabled === false || this.config.disable_session_recording === true);
+            if (!serverAllowsRecording && hasSnapshot) {
+              // remove snapshot events from the batch before sending to /batch/
+              parsed.batch = parsed.batch.filter(item => !(item && item.event === '$snapshot'));
+              // If no events remain, short-circuit and avoid sending an empty batch
+              if (!parsed.batch.length) {
+                try {
+                  // eslint-disable-next-line no-console
+                  console.debug('[Leanbase.fetch] sessionRecording disabled, dropping snapshot-only batch');
+                } catch {}
+                return {
+                  status: 200,
+                  json: async () => ({})
+                };
+              }
+              // re-encode the body so the underlying fetch receives the modified batch
+              try {
+                const newBody = JSON.stringify(parsed);
+                options = {
+                  ...options,
+                  body: newBody
+                };
+              } catch {}
+            }
+          } 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);
           }
         }