@leanbase-giangnd/js 0.0.3 → 0.0.5

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { isArray, isString, isNullish, isFormData, hasOwnProperty, isNumber, isNull, PostHogPersistedProperty, isUndefined, isFile, isFunction, includes, stripLeadingDollar, isObject, isEmptyObject, isBoolean, trim, clampToRange, BucketedRateLimiter, PostHogCore, getFetch, isEmptyString } from '@posthog/core';
-import { strFromU8, gzipSync, strToU8, decompressSync } from 'fflate';
+import { gzipSync, strToU8, strFromU8, decompressSync } from 'fflate';
 import { record } from '@rrweb/record';
 
 const breaker = {};
@@ -1183,7 +1183,7 @@ const detectDeviceType = function (user_agent) {
   }
 };
 
-var version = "0.0.3";
+var version = "0.0.5";
 var packageInfo = {
 	version: version};
 
@@ -4415,6 +4415,53 @@ class MutationThrottler {
   }
 }
 
+/**
+ * Leanbase-only SnapshotTransport
+ * Sends gzip-compressed snapshot payloads directly to the /s/ endpoint.
+ * This bypasses `posthog.capture()` and the analytics /batch/ queue.
+ *
+ * Reasoning: session replay snapshots must not enter the batch/persisted
+ * queues managed by @posthog/core. This transport posts directly to the
+ * recorder endpoint and uses the instance.fetch() implementation so it
+ * runs in the same environment the SDK uses.
+ */
+async function sendSnapshotDirect(instance, url, payload) {
+  const fetchFn = instance && instance.fetch ? instance.fetch.bind(instance) : globalThis.fetch;
+  const body = JSON.stringify(payload);
+  const compressed = gzipSync(strToU8(body));
+  const headers = {
+    'Content-Encoding': 'gzip',
+    'Content-Type': 'application/json',
+    Accept: 'application/json'
+  };
+  if (!fetchFn) {
+    // best-effort: if no fetch available, fail silently (recorder should not crash app)
+    try {
+      // eslint-disable-next-line no-console
+      console.debug('[SnapshotTransport] no fetch available, dropping snapshot');
+    } catch {}
+    return {
+      status: 0
+    };
+  }
+  try {
+    // Use the instance.fetch wrapper so environment-specific shims are used.
+    return await fetchFn(url, {
+      method: 'POST',
+      body: compressed,
+      headers
+    });
+  } catch (err) {
+    try {
+      // eslint-disable-next-line no-console
+      console.debug('[SnapshotTransport] send failed', err);
+    } catch {}
+    return {
+      status: 0
+    };
+  }
+}
+
 function simpleHash(str) {
   let hash = 0;
   for (let i = 0; i < str.length; i++) {
@@ -4442,7 +4489,6 @@ const FIVE_MINUTES = ONE_MINUTE * 5;
 const RECORDING_IDLE_THRESHOLD_MS = FIVE_MINUTES;
 const RECORDING_MAX_EVENT_SIZE = ONE_KB * ONE_KB * 0.9; // ~1mb (with some wiggle room)
 const RECORDING_BUFFER_TIMEOUT = 2000; // 2 seconds
-const SESSION_RECORDING_BATCH_KEY = 'recordings';
 const LOGGER_PREFIX$1 = '[SessionRecording]';
 const logger = createLogger(LOGGER_PREFIX$1);
 const ACTIVE_SOURCES = [IncrementalSource.MouseMove, IncrementalSource.MouseInteraction, IncrementalSource.Scroll, IncrementalSource.ViewportResize, IncrementalSource.Input, IncrementalSource.TouchMove, IncrementalSource.MediaInteraction, IncrementalSource.Drag];
@@ -5160,14 +5206,31 @@ class LazyLoadedSessionRecording {
       }, RECORDING_BUFFER_TIMEOUT);
     }
   }
-  _captureSnapshot(properties) {
-    // :TRICKY: Make sure we batch these requests, use a custom endpoint and don't truncate the strings.
-    this._instance.capture('$snapshot', properties, {
-      _url: this._snapshotUrl(),
-      _noTruncate: true,
-      _batchKey: SESSION_RECORDING_BATCH_KEY,
-      skip_client_rate_limiting: true
-    });
+  async _captureSnapshot(properties) {
+    // Send snapshots directly to the recorder endpoint to avoid the core
+    // analytics batching and persisted queue. The lifecycle gate in
+    // SessionRecording ensures this method is only called when recording
+    // is allowed.
+    try {
+      const url = this._snapshotUrl();
+      // include minimal metadata expected by /s/ endpoint
+      const payload = {
+        $snapshot_bytes: properties.$snapshot_bytes,
+        $snapshot_data: properties.$snapshot_data,
+        $session_id: properties.$session_id,
+        $window_id: properties.$window_id,
+        $lib: properties.$lib,
+        $lib_version: properties.$lib_version,
+        // include distinct_id from persistence for server-side association
+        distinct_id: this._instance.persistence?.get_property('distinct_id')
+      };
+      await sendSnapshotDirect(this._instance, url, payload);
+    } catch (err) {
+      try {
+        // eslint-disable-next-line no-console
+        console.debug('[SessionRecording] snapshot send failed', err);
+      } catch {}
+    }
   }
   _snapshotUrl() {
     const host = this._instance.config.host || '';
@@ -5883,6 +5946,35 @@ class Leanbase extends PostHogCore {
             // 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;