@leanbase-giangnd/js 0.1.5 → 0.2.3

package/dist/index.cjs

@@ -1,7 +1,6 @@
 'use strict';
 
 var core = require('@posthog/core');
-var record = require('@rrweb/record');
 var fflate = require('fflate');
 
 const breaker = {};
@@ -17,6 +16,8 @@ global?.fetch;
 global?.XMLHttpRequest && 'withCredentials' in new global.XMLHttpRequest() ? global.XMLHttpRequest : undefined;
 global?.AbortController;
 const userAgent = navigator$1?.userAgent;
+// assignableWindow mirrors browser package's assignableWindow for extension loading shims
+const assignableWindow = win ?? {};
 function eachArray(obj, iterator, thisArg) {
   if (core.isArray(obj)) {
     if (nativeForEach && obj.forEach === nativeForEach) {
@@ -1170,7 +1171,7 @@ const detectDeviceType = function (user_agent) {
   }
 };
 
-var version = "0.1.5";
+var version = "0.2.3";
 var packageInfo = {
 	version: version};
 
@@ -3108,12 +3109,101 @@ const isLikelyBot = function (navigator, customBlockedUserAgents) {
   // It would be very bad if posthog-js caused a permission prompt to appear on every page load.
 };
 
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// We avoid importing '@rrweb/record' at module load time to prevent IIFE builds
+// from requiring a top-level global. Instead, expose a lazy proxy that will
+// dynamically import the module the first time it's used.
+let _cachedRRWeb = null;
+async function _loadRRWebModule() {
+  if (_cachedRRWeb) return _cachedRRWeb;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const mod = await import('@rrweb/record');
+    _cachedRRWeb = mod;
+    return _cachedRRWeb;
+  } catch (e) {
+    return null;
+  }
+}
+// queue for method calls before rrweb loads
+const _queuedCalls = [];
+// Create a proxy function that delegates to the real rrweb.record when called
+const rrwebRecordProxy = function (...args) {
+  let realStop;
+  let calledReal = false;
+  // Start loading asynchronously and call the real record when available
+  void (async () => {
+    const mod = await _loadRRWebModule();
+    const real = mod && (mod.record ?? mod.default?.record);
+    if (real) {
+      try {
+        calledReal = true;
+        realStop = real(...args);
+        // flush any queued calls that were waiting for rrweb
+        while (_queuedCalls.length) {
+          try {
+            const fn = _queuedCalls.shift();
+            fn();
+          } catch (e) {
+            // ignore
+          }
+        }
+      } catch (e) {
+        // ignore
+      }
+    }
+  })();
+  // return a stop function that will call the real stop when available
+  return () => {
+    if (realStop) {
+      try {
+        realStop();
+      } catch (e) {
+        // ignore
+      }
+    } else if (!calledReal) {
+      // If rrweb hasn't been initialised yet, queue a stop request that will
+      // call the real stop once available.
+      _queuedCalls.push(() => {
+        try {
+          realStop?.();
+        } catch (e) {
+          // ignore
+        }
+      });
+    }
+  };
+};
+// methods that can be called on the rrweb.record object - queue until real module is available
+rrwebRecordProxy.addCustomEvent = function (tag, payload) {
+  const call = () => {
+    try {
+      const real = _cachedRRWeb && (_cachedRRWeb.record ?? _cachedRRWeb.default?.record);
+      real?.addCustomEvent?.(tag, payload);
+    } catch (e) {
+      // ignore
+    }
+  };
+  if (_cachedRRWeb) call();else _queuedCalls.push(call);
+};
+rrwebRecordProxy.takeFullSnapshot = function () {
+  const call = () => {
+    try {
+      const real = _cachedRRWeb && (_cachedRRWeb.record ?? _cachedRRWeb.default?.record);
+      real?.takeFullSnapshot?.();
+    } catch (e) {
+      // ignore
+    }
+  };
+  if (_cachedRRWeb) call();else _queuedCalls.push(call);
+};
 // Use a safe global target (prefer `win`, fallback to globalThis)
 const _target = win ?? globalThis;
 _target.__PosthogExtensions__ = _target.__PosthogExtensions__ || {};
-// Expose rrweb.record under the same contract
+// Expose rrweb.record under the same contract. We provide a lazy proxy so
+// builds that execute this file don't require rrweb at module evaluation time.
 _target.__PosthogExtensions__.rrweb = _target.__PosthogExtensions__.rrweb || {
-  record: record.record
+  record: rrwebRecordProxy
 };
 // Provide initSessionRecording if not present — return a new LazyLoadedSessionRecording when called
 _target.__PosthogExtensions__.initSessionRecording = _target.__PosthogExtensions__.initSessionRecording || (instance => {
@@ -3866,7 +3956,41 @@ function getRRWebRecord() {
   } catch {
     // ignore
   }
-  return record.record;
+  // If we've previously loaded rrweb via dynamic import, return the cached reference
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const cached = getRRWebRecord._cachedRRWebRecord;
+  return cached;
+}
+async function loadRRWeb() {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const ext = globalThis.__PosthogExtensions__;
+    if (ext && ext.rrweb && ext.rrweb.record) {
+      ;
+      getRRWebRecord._cachedRRWebRecord = ext.rrweb.record;
+      return ext.rrweb.record;
+    }
+    // If already cached, return it
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const already = getRRWebRecord._cachedRRWebRecord;
+    if (already) {
+      return already;
+    }
+    // Dynamic import - let the bundler (IIFE build) include rrweb in the bundle or allow lazy-load
+    // Note: we intentionally use a dynamic import so rrweb is not referenced at the module top-level
+    // which would cause IIFE builds to assume a global is present at script execution.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const mod = await import('@rrweb/record');
+    const rr = mod && (mod.record ?? (mod.default && mod.default.record));
+    if (rr) {
+      ;
+      getRRWebRecord._cachedRRWebRecord = rr;
+      return rr;
+    }
+  } catch (e) {
+    logger.error('could not dynamically load rrweb', e);
+  }
+  return null;
 }
 function gzipToString(data) {
   return fflate.strFromU8(fflate.gzipSync(fflate.strToU8(JSON.stringify(data))), true);
@@ -4289,7 +4413,7 @@ class LazyLoadedSessionRecording {
     const parsedConfig = core.isObject(persistedConfig) ? persistedConfig : JSON.parse(persistedConfig);
     return parsedConfig;
   }
-  start(startReason) {
+  async start(startReason) {
     const config = this._remoteConfig;
     if (!config) {
       logger.info('remote config must be stored in persistence before recording can start');
@@ -4323,7 +4447,12 @@ class LazyLoadedSessionRecording {
       });
     });
     this._makeSamplingDecision(this.sessionId);
-    this._startRecorder();
+    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);
@@ -4779,7 +4908,7 @@ class LazyLoadedSessionRecording {
       $sdk_debug_session_start: sessionStartTimestamp
     };
   }
-  _startRecorder() {
+  async _startRecorder() {
     if (this._stopRrweb) {
       return;
     }
@@ -4835,7 +4964,12 @@ class LazyLoadedSessionRecording {
       sessionRecordingOptions.maskTextSelector = this._masking.maskTextSelector ?? undefined;
       sessionRecordingOptions.blockSelector = this._masking.blockSelector ?? undefined;
     }
-    const rrwebRecord = getRRWebRecord();
+    // Ensure rrweb is loaded (either via global extension or dynamic import)
+    let rrwebRecord = getRRWebRecord();
+    if (!rrwebRecord) {
+      const loaded = await loadRRWeb();
+      rrwebRecord = loaded ?? undefined;
+    }
     if (!rrwebRecord) {
       logger.error('_startRecorder was called but rrwebRecord is not available. This indicates something has gone wrong.');
       return;
@@ -4852,13 +4986,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
@@ -4877,6 +5017,7 @@ class LazyLoadedSessionRecording {
   }
 }
 
+/* eslint-disable posthog-js/no-direct-function-check */
 const LOGGER_PREFIX = '[SessionRecording]';
 const log = {
   info: (...args) => logger$2.info(LOGGER_PREFIX, ...args),
@@ -4945,6 +5086,18 @@ class SessionRecording {
     if (!this._isRecordingEnabled) {
       return;
     }
+    // If extensions provide a loader, use it. Otherwise fallback to the local _onScriptLoaded which
+    // will create the local LazyLoadedSessionRecording (so tests that mock it work correctly).
+    const loader = assignableWindow.__PosthogExtensions__?.loadExternalDependency;
+    if (typeof loader === 'function') {
+      loader(this._instance, this._scriptName, err => {
+        if (err) {
+          return log.error('could not load recorder', err);
+        }
+        this._onScriptLoaded(startReason);
+      });
+      return;
+    }
     this._onScriptLoaded(startReason);
   }
   stopRecording() {
@@ -5023,12 +5176,47 @@ class SessionRecording {
       logger$2.warn('log called before recorder was ready');
     }
   }
+  get _scriptName() {
+    const remoteConfig = this._instance?.persistence?.get_property(SESSION_RECORDING_REMOTE_CONFIG);
+    return remoteConfig?.scriptConfig?.script || 'lazy-recorder';
+  }
   _onScriptLoaded(startReason) {
+    // If extensions provide an init function, use it. Otherwise, fall back to the local LazyLoadedSessionRecording
+    if (assignableWindow.__PosthogExtensions__?.initSessionRecording) {
+      if (!this._lazyLoadedSessionRecording) {
+        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');
+        }
+      }
+      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);
+        }
+        return;
+      }
+    }
     if (!this._lazyLoadedSessionRecording) {
       this._lazyLoadedSessionRecording = new LazyLoadedSessionRecording(this._instance);
       this._lazyLoadedSessionRecording._forceAllowLocalhostNetworkCapture = this._forceAllowLocalhostNetworkCapture;
     }
-    this._lazyLoadedSessionRecording.start(startReason);
+    // start may perform a dynamic import; handle both sync and Promise returns
+    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);
+    }
   }
   /**
    * this is maintained on the public API only because it has always been on the public API
@@ -5129,6 +5317,10 @@ class Leanbase extends core.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;
@@ -5152,10 +5344,20 @@ class Leanbase extends core.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) {
@@ -5165,9 +5367,26 @@ class Leanbase extends core.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
     });
@@ -5204,11 +5423,19 @@ class Leanbase extends core.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) {
@@ -5221,6 +5448,26 @@ class Leanbase extends core.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 = core.getFetch();