@leanbase-giangnd/js 0.2.2 → 0.2.3

package/dist/index.d.ts

@@ -6127,6 +6127,10 @@ declare class Leanbase extends PostHogCore {
     consent: ConsentManager;
     sessionRecording?: SessionRecording$1;
     isRemoteConfigLoaded?: boolean;
+    private _remoteConfigLoadAttempted;
+    private _remoteConfigResolved;
+    private _featureFlagsResolved;
+    private _maybeStartedSessionRecording;
     personProcessingSetOncePropertiesSent: boolean;
     isLoaded: boolean;
     initialPageviewCaptured: boolean;
@@ -6137,6 +6141,7 @@ declare class Leanbase extends PostHogCore {
     capturePageLeave(): void;
     loadRemoteConfig(): Promise<void>;
     onRemoteConfig(config: RemoteConfig$1): void;
+    private _maybeStartSessionRecording;
     fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse>;
     setConfig(config: Partial<LeanbaseConfig>): void;
     getLibraryId(): string;

package/dist/index.mjs

@@ -1169,7 +1169,7 @@ const detectDeviceType = function (user_agent) {
   }
 };
 
-var version = "0.2.2";
+var version = "0.2.3";
 var packageInfo = {
 	version: version};
 
@@ -4446,6 +4446,11 @@ class LazyLoadedSessionRecording {
     });
     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);
@@ -4979,13 +4984,19 @@ class LazyLoadedSessionRecording {
       }
     });
     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
@@ -5171,18 +5182,25 @@ class SessionRecording {
     // 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);
@@ -5297,6 +5315,10 @@ class Leanbase extends PostHogCore {
       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;
@@ -5320,10 +5342,20 @@ class Leanbase extends PostHogCore {
     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) {
@@ -5333,9 +5365,26 @@ class Leanbase extends PostHogCore {
         }
       }, 1);
     }
-    addEventListener(document, 'DOMContentLoaded', () => {
-      this.loadRemoteConfig();
-    });
+    const triggerRemoteConfigLoad = reason => {
+      logger$2.info(`remote config load triggered via ${reason}`);
+      void this.loadRemoteConfig();
+    };
+    if (document) {
+      if (document.readyState === 'loading') {
+        logger$2.info('remote config load deferred until DOMContentLoaded');
+        const onDomReady = () => {
+          document?.removeEventListener('DOMContentLoaded', onDomReady);
+          triggerRemoteConfigLoad('dom');
+        };
+        addEventListener(document, 'DOMContentLoaded', onDomReady, {
+          once: true
+        });
+      } else {
+        triggerRemoteConfigLoad('immediate');
+      }
+    } else {
+      triggerRemoteConfigLoad('no-document');
+    }
     addEventListener(window, 'onpagehide' in self ? 'pagehide' : 'unload', this.capturePageLeave.bind(this), {
       passive: false
     });
@@ -5372,11 +5421,19 @@ class Leanbase extends PostHogCore {
     }
   }
   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) {
@@ -5389,6 +5446,26 @@ class Leanbase extends PostHogCore {
     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();