@leanbase-giangnd/js 0.2.2 → 0.2.3

package/dist/leanbase.iife.js

@@ -2846,7 +2846,7 @@ var leanbase = (function () {
       }
     };
 
-    var version = "0.2.2";
+    var version = "0.2.3";
     var packageInfo = {
     	version: version};
 
@@ -6707,6 +6707,11 @@ var leanbase = (function () {
         });
         this._makeSamplingDecision(this.sessionId);
         await this._startRecorder();
+        // If rrweb failed to load/start, do not proceed further.
+        // This prevents installing listeners that assume rrweb is active.
+        if (!this.isStarted) {
+          return;
+        }
         // calling addEventListener multiple times is safe and will not add duplicates
         addEventListener(win, 'beforeunload', this._onBeforeUnload);
         addEventListener(win, 'offline', this._onOffline);
@@ -7240,13 +7245,19 @@ var leanbase = (function () {
           }
         });
         const activePlugins = this._gatherRRWebPlugins();
-        this._stopRrweb = rrwebRecord({
-          emit: event => {
-            this.onRRwebEmit(event);
-          },
-          plugins: activePlugins,
-          ...sessionRecordingOptions
-        });
+        try {
+          this._stopRrweb = rrwebRecord({
+            emit: event => {
+              this.onRRwebEmit(event);
+            },
+            plugins: activePlugins,
+            ...sessionRecordingOptions
+          });
+        } catch (e) {
+          logger.error('failed to start rrweb recorder', e);
+          this._stopRrweb = undefined;
+          return;
+        }
         // We reset the last activity timestamp, resetting the idle timer
         this._lastActivityTimestamp = Date.now();
         // stay unknown if we're not sure if we're idle or not
@@ -7432,18 +7443,25 @@ var leanbase = (function () {
         // If extensions provide an init function, use it. Otherwise, fall back to the local LazyLoadedSessionRecording
         if (assignableWindow.__PosthogExtensions__?.initSessionRecording) {
           if (!this._lazyLoadedSessionRecording) {
-            this._lazyLoadedSessionRecording = assignableWindow.__PosthogExtensions__?.initSessionRecording(this._instance);
-            this._lazyLoadedSessionRecording._forceAllowLocalhostNetworkCapture = this._forceAllowLocalhostNetworkCapture;
+            const maybeRecording = assignableWindow.__PosthogExtensions__?.initSessionRecording(this._instance);
+            if (maybeRecording && typeof maybeRecording.start === 'function') {
+              this._lazyLoadedSessionRecording = maybeRecording;
+              this._lazyLoadedSessionRecording._forceAllowLocalhostNetworkCapture = this._forceAllowLocalhostNetworkCapture;
+            } else {
+              log.warn('initSessionRecording was present but did not return a recorder instance; falling back to local recorder');
+            }
           }
-          try {
-            const maybePromise = this._lazyLoadedSessionRecording.start(startReason);
-            if (maybePromise && typeof maybePromise.catch === 'function') {
-              maybePromise.catch(e => logger$2.error('error starting session recording', e));
+          if (this._lazyLoadedSessionRecording) {
+            try {
+              const maybePromise = this._lazyLoadedSessionRecording.start(startReason);
+              if (maybePromise && typeof maybePromise.catch === 'function') {
+                maybePromise.catch(e => logger$2.error('error starting session recording', e));
+              }
+            } catch (e) {
+              logger$2.error('error starting session recording', e);
             }
-          } catch (e) {
-            logger$2.error('error starting session recording', e);
+            return;
           }
-          return;
         }
         if (!this._lazyLoadedSessionRecording) {
           this._lazyLoadedSessionRecording = new LazyLoadedSessionRecording(this._instance);
@@ -7558,6 +7576,10 @@ var leanbase = (function () {
           token
         });
         super(token, mergedConfig);
+        this._remoteConfigLoadAttempted = false;
+        this._remoteConfigResolved = false;
+        this._featureFlagsResolved = false;
+        this._maybeStartedSessionRecording = false;
         this.personProcessingSetOncePropertiesSent = false;
         this.isLoaded = false;
         this.config = mergedConfig;
@@ -7581,10 +7603,20 @@ var leanbase = (function () {
         this.replayAutocapture.startIfEnabled();
         if (this.sessionManager && this.config.cookieless_mode !== 'always') {
           this.sessionRecording = new SessionRecording(this);
-          this.sessionRecording.startIfEnabledOrStop();
         }
+        // Start session recording only once flags + remote config have been resolved.
+        // This matches the PostHog browser SDK where replay activation is driven by remote config and flags.
         if (this.config.preloadFeatureFlags !== false) {
-          this.reloadFeatureFlags();
+          this.reloadFeatureFlags({
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            cb: _err => {
+              this._featureFlagsResolved = true;
+              this._maybeStartSessionRecording();
+            }
+          });
+        } else {
+          // If feature flags preload is explicitly disabled, treat this requirement as satisfied.
+          this._featureFlagsResolved = true;
         }
         this.config.loaded?.(this);
         if (this.config.capture_pageview) {
@@ -7594,9 +7626,26 @@ var leanbase = (function () {
             }
           }, 1);
         }
-        addEventListener(document$1, 'DOMContentLoaded', () => {
-          this.loadRemoteConfig();
-        });
+        const triggerRemoteConfigLoad = reason => {
+          logger$2.info(`remote config load triggered via ${reason}`);
+          void this.loadRemoteConfig();
+        };
+        if (document$1) {
+          if (document$1.readyState === 'loading') {
+            logger$2.info('remote config load deferred until DOMContentLoaded');
+            const onDomReady = () => {
+              document$1?.removeEventListener('DOMContentLoaded', onDomReady);
+              triggerRemoteConfigLoad('dom');
+            };
+            addEventListener(document$1, 'DOMContentLoaded', onDomReady, {
+              once: true
+            });
+          } else {
+            triggerRemoteConfigLoad('immediate');
+          }
+        } else {
+          triggerRemoteConfigLoad('no-document');
+        }
         addEventListener(window, 'onpagehide' in self ? 'pagehide' : 'unload', this.capturePageLeave.bind(this), {
           passive: false
         });
@@ -7633,11 +7682,19 @@ var leanbase = (function () {
         }
       }
       async loadRemoteConfig() {
-        if (!this.isRemoteConfigLoaded) {
+        if (this._remoteConfigLoadAttempted) {
+          return;
+        }
+        this._remoteConfigLoadAttempted = true;
+        try {
           const remoteConfig = await this.reloadRemoteConfigAsync();
           if (remoteConfig) {
             this.onRemoteConfig(remoteConfig);
           }
+        } finally {
+          // Regardless of success/failure, we consider remote config "resolved" so replay isn't blocked forever.
+          this._remoteConfigResolved = true;
+          this._maybeStartSessionRecording();
         }
       }
       onRemoteConfig(config) {
@@ -7650,6 +7707,26 @@ var leanbase = (function () {
         this.isRemoteConfigLoaded = true;
         this.replayAutocapture?.onRemoteConfig(config);
         this.sessionRecording?.onRemoteConfig(config);
+        // Remote config has been applied; allow replay start if flags are also ready.
+        this._remoteConfigResolved = true;
+        this._maybeStartSessionRecording();
+      }
+      _maybeStartSessionRecording() {
+        if (this._maybeStartedSessionRecording) {
+          return;
+        }
+        if (!this.sessionRecording) {
+          return;
+        }
+        if (!this._featureFlagsResolved || !this._remoteConfigResolved) {
+          return;
+        }
+        this._maybeStartedSessionRecording = true;
+        try {
+          this.sessionRecording.startIfEnabledOrStop();
+        } catch (e) {
+          logger$2.error('Failed to start session recording', e);
+        }
       }
       fetch(url, options) {
         const fetchFn = getFetch();