@leanbase-giangnd/js 0.3.0 → 0.3.2

package/dist/leanbase.iife.js

@@ -2846,7 +2846,7 @@ var leanbase = (function () {
       }
     };
 
-    var version = "0.3.0";
+    var version = "0.3.2";
     var packageInfo = {
     	version: version};
 
@@ -4785,117 +4785,20 @@ var leanbase = (function () {
     };
 
     /* 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 Promise.resolve().then(function () { return record$1; });
-        _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. 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: rrwebRecordProxy
-    };
-    // Provide initSessionRecording if not present — return a new LazyLoadedSessionRecording when called
+    _target.__PosthogExtensions__.rrweb = _target.__PosthogExtensions__.rrweb || {};
     _target.__PosthogExtensions__.initSessionRecording = _target.__PosthogExtensions__.initSessionRecording || (instance => {
       const factory = _target.__PosthogExtensions__._initSessionRecordingFactory;
       if (factory) {
         return factory(instance);
       }
-      // If no factory is registered yet, return undefined — callers should handle lazy-loading.
       return undefined;
     });
-    // Provide a no-op loadExternalDependency that calls the callback immediately (since rrweb is bundled)
     _target.__PosthogExtensions__.loadExternalDependency = _target.__PosthogExtensions__.loadExternalDependency || ((instance, scriptName, cb) => {
       if (cb) cb(undefined);
     });
-    // Provide rrwebPlugins object with network plugin factory if not present
     _target.__PosthogExtensions__.rrwebPlugins = _target.__PosthogExtensions__.rrwebPlugins || {};
-    // Default to undefined; the lazy-loaded recorder will register the real factory when it initializes.
     _target.__PosthogExtensions__.rrwebPlugins.getRecordNetworkPlugin = _target.__PosthogExtensions__.rrwebPlugins.getRecordNetworkPlugin || (() => undefined);
 
     // Type definitions copied from @rrweb/types@2.0.0-alpha.17 and rrweb-snapshot@2.0.0-alpha.17
@@ -6150,10 +6053,8 @@ var leanbase = (function () {
             return event;
           }
         };
-        const configuredBucketSize = this._options.bucketSize ?? 100;
-        const effectiveBucketSize = Math.max(configuredBucketSize - 1, 1);
         this._rateLimiter = new BucketedRateLimiter({
-          bucketSize: effectiveBucketSize,
+          bucketSize: this._options.bucketSize ?? 100,
           refillRate: this._options.refillRate ?? 10,
           refillInterval: 1000,
           // one second
@@ -6349,6 +6250,23 @@ var leanbase = (function () {
       get sessionId() {
         return this._sessionId;
       }
+      _disablePermanently(reason, error) {
+        this._permanentlyDisabled = true;
+        this._isFullyReady = false;
+        this._mutationThrottler?.stop();
+        this._mutationThrottler = undefined;
+        this._queuedRRWebEvents = [];
+        this._recording = undefined;
+        this._stopRrweb = undefined;
+        if (!this._loggedPermanentlyDisabled) {
+          this._loggedPermanentlyDisabled = true;
+          if (error) {
+            logger.error(`replay disabled: ${reason}`, error);
+          } else {
+            logger.error(`replay disabled: ${reason}`);
+          }
+        }
+      }
       get _sessionManager() {
         if (!this._instance.sessionManager) {
           throw new Error(LOGGER_PREFIX$1 + ' must be started with a valid sessionManager.');
@@ -6380,6 +6298,9 @@ var leanbase = (function () {
          */
         this._forceAllowLocalhostNetworkCapture = false;
         this._stopRrweb = undefined;
+        this._permanentlyDisabled = false;
+        this._loggedPermanentlyDisabled = false;
+        this._hasReportedRecordingInitialized = false;
         this._lastActivityTimestamp = Date.now();
         /**
          * and a queue - that contains rrweb events that we want to send to rrweb, but rrweb wasn't able to accept them yet
@@ -6569,6 +6490,9 @@ var leanbase = (function () {
         }
       }
       _tryAddCustomEvent(tag, payload) {
+        if (!this.isStarted || !this._recording) {
+          return false;
+        }
         const rrwebRecord = getRRWebRecord();
         if (!rrwebRecord || typeof rrwebRecord.addCustomEvent !== 'function') {
           return false;
@@ -6598,6 +6522,10 @@ var leanbase = (function () {
         }
       }
       _processQueuedEvents() {
+        if (!this.isStarted || !this._recording) {
+          this._queuedRRWebEvents = [];
+          return;
+        }
         if (this._queuedRRWebEvents.length) {
           // if rrweb isn't ready to accept events earlier, then we queued them up.
           // now that `emit` has been called rrweb should be ready to accept them.
@@ -6619,6 +6547,9 @@ var leanbase = (function () {
         }
       }
       _tryTakeFullSnapshot() {
+        if (!this.isStarted || !this._recording) {
+          return false;
+        }
         const rrwebRecord = getRRWebRecord();
         if (!rrwebRecord || typeof rrwebRecord.takeFullSnapshot !== 'function') {
           return false;
@@ -6632,6 +6563,9 @@ var leanbase = (function () {
         return this._instance.config.session_recording?.full_snapshot_interval_millis ?? FIVE_MINUTES;
       }
       _scheduleFullSnapshot() {
+        if (!this.isStarted || !this._recording) {
+          return;
+        }
         if (this._fullSnapshotTimer) {
           clearInterval(this._fullSnapshotTimer);
         }
@@ -6648,6 +6582,9 @@ var leanbase = (function () {
         }, interval);
       }
       _pauseRecording() {
+        if (!this.isStarted || !this._recording) {
+          return;
+        }
         // we check _urlBlocked not status, since more than one thing can affect status
         if (this._urlTriggerMatching.urlBlocked) {
           return;
@@ -6665,6 +6602,9 @@ var leanbase = (function () {
         });
       }
       _resumeRecording() {
+        if (!this.isStarted || !this._recording) {
+          return;
+        }
         // we check _urlBlocked not status, since more than one thing can affect status
         if (!this._urlTriggerMatching.urlBlocked) {
           return;
@@ -6678,6 +6618,9 @@ var leanbase = (function () {
         logger.info('recording resumed');
       }
       _activateTrigger(triggerType) {
+        if (!this.isStarted || !this._recording || !this._isFullyReady) {
+          return;
+        }
         if (this._triggerMatching.triggerStatus(this.sessionId) === TRIGGER_PENDING) {
           // status is stored separately for URL and event triggers
           this._instance?.persistence?.register({
@@ -6688,7 +6631,7 @@ var leanbase = (function () {
         }
       }
       get isStarted() {
-        return !!this._stopRrweb;
+        return !!this._recording?.stop;
       }
       get _remoteConfig() {
         const persistedConfig = this._instance.get_property(SESSION_RECORDING_REMOTE_CONFIG);
@@ -6699,6 +6642,9 @@ var leanbase = (function () {
         return parsedConfig;
       }
       async start(startReason) {
+        if (this._permanentlyDisabled) {
+          return;
+        }
         this._isFullyReady = false;
         const config = this._remoteConfig;
         if (!config) {
@@ -6724,8 +6670,14 @@ var leanbase = (function () {
         });
         this._urlTriggerMatching.onConfig(config);
         this._eventTriggerMatching.onConfig(config);
-        this._removeEventTriggerCaptureHook?.();
-        this._addEventTriggerListener();
+        // Start rrweb first; only once we have a valid recorder do we install any listeners/timers.
+        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;
+        }
+        // Now that rrweb has started, we can safely install replay side-effects.
         this._linkedFlagMatching.onConfig(config, (flag, variant) => {
           this._reportStarted('linked_flag_matched', {
             flag,
@@ -6733,12 +6685,8 @@ 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;
-        }
+        this._removeEventTriggerCaptureHook?.();
+        this._addEventTriggerListener();
         // Only start processing rrweb emits once the ingestion endpoint is available.
         // If it isn't available, we must degrade to a no-op (never crash the host app).
         this._isFullyReady = this._canCaptureSnapshots();
@@ -6788,7 +6736,13 @@ var leanbase = (function () {
           });
         }
         if (this.status === ACTIVE) {
-          this._reportStarted(startReason || 'recording_initialized');
+          const reason = startReason || 'recording_initialized';
+          if (reason !== 'recording_initialized' || !this._hasReportedRecordingInitialized) {
+            if (reason === 'recording_initialized') {
+              this._hasReportedRecordingInitialized = true;
+            }
+            this._reportStarted(reason);
+          }
         }
       }
       stop() {
@@ -6817,9 +6771,11 @@ var leanbase = (function () {
         this._mutationThrottler?.stop();
         // Clear any queued rrweb events to prevent memory leaks from closures
         this._queuedRRWebEvents = [];
-        this._stopRrweb?.();
+        this._recording?.stop?.();
+        this._recording = undefined;
         this._stopRrweb = undefined;
         this._isFullyReady = false;
+        this._hasReportedRecordingInitialized = false;
         logger.info('stopped');
       }
       _snapshotIngestionUrl() {
@@ -6837,8 +6793,12 @@ var leanbase = (function () {
         return !!this._snapshotIngestionUrl();
       }
       onRRwebEmit(rawEvent) {
+        // First-line invariant gate: drop everything unless replay is truly started.
+        if (!this.isStarted || !this._recording) {
+          return;
+        }
         // Never process rrweb emits until we're fully ready.
-        if (!this._isFullyReady || !this.isStarted) {
+        if (!this._isFullyReady) {
           return;
         }
         try {
@@ -6943,6 +6903,9 @@ var leanbase = (function () {
         });
       }
       overrideLinkedFlag() {
+        if (!this.isStarted || !this._recording || !this._isFullyReady) {
+          return;
+        }
         this._linkedFlagMatching.linkedFlagSeen = true;
         this._tryTakeFullSnapshot();
         this._reportStarted('linked_flag_overridden');
@@ -6954,6 +6917,9 @@ var leanbase = (function () {
        * instead call `posthog.startSessionRecording({sampling: true})`
        * */
       overrideSampling() {
+        if (!this.isStarted || !this._recording || !this._isFullyReady) {
+          return;
+        }
         this._instance.persistence?.register({
           // short-circuits the `makeSamplingDecision` function in the session recording module
           [SESSION_RECORDING_IS_SAMPLED]: this.sessionId
@@ -6968,6 +6934,9 @@ var leanbase = (function () {
        * instead call `posthog.startSessionRecording({trigger: 'url' | 'event'})`
        * */
       overrideTrigger(triggerType) {
+        if (!this.isStarted || !this._recording || !this._isFullyReady) {
+          return;
+        }
         this._activateTrigger(triggerType);
       }
       _clearFlushBufferTimer() {
@@ -7100,10 +7069,18 @@ var leanbase = (function () {
         return this._buffer;
       }
       _reportStarted(startReason, tagPayload) {
+        if (!this.isStarted || !this._recording) {
+          return;
+        }
         this._instance.registerForSession({
           $session_recording_start_reason: startReason
         });
-        logger.info(startReason.replace('_', ' '), tagPayload);
+        const message = startReason.replace('_', ' ');
+        if (typeof tagPayload === 'undefined') {
+          logger.info(message);
+        } else {
+          logger.info(message, tagPayload);
+        }
         if (!includes(['recording_initialized', 'session_id_changed'], startReason)) {
           this._tryAddCustomEvent(startReason, tagPayload);
         }
@@ -7243,7 +7220,7 @@ var leanbase = (function () {
         };
       }
       async _startRecorder() {
-        if (this._stopRrweb) {
+        if (this._permanentlyDisabled || this._recording) {
           return;
         }
         // rrweb config info: https://github.com/rrweb-io/rrweb/blob/7d5d0033258d6c29599fb08412202d9a2c7b9413/src/record/index.ts#L28
@@ -7305,27 +7282,18 @@ var leanbase = (function () {
           rrwebRecord = loaded ?? undefined;
         }
         if (!rrwebRecord) {
-          logger.error('_startRecorder was called but rrwebRecord is not available. This indicates something has gone wrong.');
+          this._disablePermanently('rrweb record function unavailable');
           return;
         }
-        this._mutationThrottler = this._mutationThrottler ?? new MutationThrottler(rrwebRecord, {
-          refillRate: this._instance.config.session_recording?.__mutationThrottlerRefillRate,
-          bucketSize: this._instance.config.session_recording?.__mutationThrottlerBucketSize,
-          onBlockedNode: (id, node) => {
-            const message = `Too many mutations on node '${id}'. Rate limiting. This could be due to SVG animations or something similar`;
-            logger.info(message, {
-              node: node
-            });
-            this.log(LOGGER_PREFIX$1 + ' ' + message, 'warn');
-          }
-        });
         const activePlugins = this._gatherRRWebPlugins();
+        let stopHandler;
         try {
-          this._stopRrweb = rrwebRecord({
+          stopHandler = rrwebRecord({
             emit: event => {
               try {
                 this.onRRwebEmit(event);
               } catch (e) {
+                // never throw from rrweb emit handler
                 logger.error('error in rrweb emit handler', e);
               }
             },
@@ -7333,10 +7301,30 @@ var leanbase = (function () {
             ...sessionRecordingOptions
           });
         } catch (e) {
-          logger.error('failed to start rrweb recorder', e);
-          this._stopRrweb = undefined;
+          this._disablePermanently('rrweb recorder threw during initialization', e);
+          return;
+        }
+        if (typeof stopHandler !== 'function') {
+          this._disablePermanently('rrweb recorder returned an invalid stop handler');
           return;
         }
+        // Mark replay started only after rrweb has successfully returned a valid stop handler.
+        this._recording = {
+          stop: stopHandler
+        };
+        this._stopRrweb = stopHandler;
+        // Only create mutation throttler once replay is truly started.
+        this._mutationThrottler = this._mutationThrottler ?? new MutationThrottler(rrwebRecord, {
+          refillRate: this._instance.config.session_recording?.__mutationThrottlerRefillRate,
+          bucketSize: this._instance.config.session_recording?.__mutationThrottlerBucketSize,
+          onBlockedNode: (id, node) => {
+            const message = `Too many mutations on node '${id}'. Rate limiting. This could be due to SVG animations or something similar`;
+            logger.info(message, {
+              node: node
+            });
+            this.log(LOGGER_PREFIX$1 + ' ' + message, 'warn');
+          }
+        });
         // 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
@@ -7366,10 +7354,6 @@ var leanbase = (function () {
       get started() {
         return !!this._lazyLoadedSessionRecording?.isStarted;
       }
-      /**
-       * defaults to buffering mode until a flags response is received
-       * once a flags response is received status can be disabled, active or sampled
-       */
       get status() {
         if (this._lazyLoadedSessionRecording) {
           return this._lazyLoadedSessionRecording.status;
@@ -7383,7 +7367,6 @@ var leanbase = (function () {
         this._instance = _instance;
         this._forceAllowLocalhostNetworkCapture = false;
         this._receivedFlags = false;
-        this._serverRecordingEnabled = false;
         this._persistFlagsOnSessionListener = undefined;
         if (!this._instance.sessionManager) {
           log.error('started without valid sessionManager');
@@ -7406,26 +7389,14 @@ var leanbase = (function () {
         const canRunReplay = !isUndefined(Object.assign) && !isUndefined(Array.from);
         if (this._isRecordingEnabled && canRunReplay) {
           this._lazyLoadAndStart(startReason);
-          log.info('starting');
         } else {
           this.stopRecording();
         }
       }
-      /**
-       * session recording waits until it receives remote config before loading the script
-       * this is to ensure we can control the script name remotely
-       * and because we wait until we have local and remote config to determine if we should start at all
-       * if start is called and there is no remote config then we wait until there is
-       */
       _lazyLoadAndStart(startReason) {
-        // by checking `_isRecordingEnabled` here we know that
-        // we have stored remote config and client config to read
-        // replay waits for both local and remote config before starting
         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 => {
@@ -7480,16 +7451,10 @@ var leanbase = (function () {
             });
           };
           persistResponse();
-          // in case we see multiple flags responses, we should only use the response from the most recent one
           this._persistFlagsOnSessionListener?.();
-          // we 100% know there is a session manager by this point
           this._persistFlagsOnSessionListener = this._instance.sessionManager?.onSessionId(persistResponse);
         }
       }
-      _clearRemoteConfig() {
-        this._instance.persistence?.unregister(SESSION_RECORDING_REMOTE_CONFIG);
-        this._resetSampling();
-      }
       onRemoteConfig(response) {
         if (!('sessionRecording' in response)) {
           // if sessionRecording is not in the response, we do nothing
@@ -7498,12 +7463,8 @@ var leanbase = (function () {
         }
         this._receivedFlags = true;
         if (response.sessionRecording === false) {
-          this._serverRecordingEnabled = false;
-          this._clearRemoteConfig();
-          this.stopRecording();
           return;
         }
-        this._serverRecordingEnabled = true;
         this._persistRemoteConfig(response);
         this.startIfEnabledOrStop();
       }
@@ -7564,59 +7525,61 @@ var leanbase = (function () {
       onRRwebEmit(rawEvent) {
         this._lazyLoadedSessionRecording?.onRRwebEmit?.(rawEvent);
       }
-      /**
-       * this ignores the linked flag config and (if other conditions are met) causes capture to start
-       *
-       * It is not usual to call this directly,
-       * instead call `posthog.startSessionRecording({linked_flag: true})`
-       * */
       overrideLinkedFlag() {
         // TODO what if this gets called before lazy loading is done
         this._lazyLoadedSessionRecording?.overrideLinkedFlag();
       }
-      /**
-       * this ignores the sampling config and (if other conditions are met) causes capture to start
-       *
-       * It is not usual to call this directly,
-       * instead call `posthog.startSessionRecording({sampling: true})`
-       * */
       overrideSampling() {
         // TODO what if this gets called before lazy loading is done
         this._lazyLoadedSessionRecording?.overrideSampling();
       }
-      /**
-       * this ignores the URL/Event trigger config and (if other conditions are met) causes capture to start
-       *
-       * It is not usual to call this directly,
-       * instead call `posthog.startSessionRecording({trigger: 'url' | 'event'})`
-       * */
       overrideTrigger(triggerType) {
         // TODO what if this gets called before lazy loading is done
         this._lazyLoadedSessionRecording?.overrideTrigger(triggerType);
       }
-      /*
-       * whenever we capture an event, we add these properties to the event
-       * these are used to debug issues with the session recording
-       * when looking at the event feed for a session
-       */
       get sdkDebugProperties() {
         return this._lazyLoadedSessionRecording?.sdkDebugProperties || {
           $recording_status: this.status
         };
       }
-      /**
-       * This adds a custom event to the session recording
-       *
-       * It is not intended for arbitrary public use - playback only displays known custom events
-       * And is exposed on the public interface only so that other parts of the SDK are able to use it
-       *
-       * if you are calling this from client code, you're probably looking for `posthog.capture('$custom_event', {...})`
-       */
       tryAddCustomEvent(tag, payload) {
         return !!this._lazyLoadedSessionRecording?.tryAddCustomEvent(tag, payload);
       }
     }
 
+    /**
+     * Leanbase-local version of PostHog's RequestRouter.
+     *
+     * Browser SDK always has a requestRouter instance; Leanbase IIFE needs this too so
+     * features like Session Replay can construct ingestion URLs.
+     */
+    class RequestRouter {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      constructor(instance) {
+        this.instance = instance;
+      }
+      get apiHost() {
+        const configured = (this.instance.config.api_host || this.instance.config.host || '').trim();
+        return configured.replace(/\/$/, '');
+      }
+      get uiHost() {
+        const configured = this.instance.config.ui_host?.trim().replace(/\/$/, '');
+        return configured || undefined;
+      }
+      endpointFor(target, path = '') {
+        if (path) {
+          path = path[0] === '/' ? path : `/${path}`;
+        }
+        if (target === 'ui') {
+          const host = this.uiHost || this.apiHost;
+          return host + path;
+        }
+        // Leanbase doesn't currently do region-based routing; default to apiHost.
+        // Browser's router has special handling for assets; we keep parity in interface, not domains.
+        return this.apiHost + path;
+      }
+    }
+
     const defaultConfig = () => ({
       host: 'https://i.leanbase.co',
       token: '',
@@ -7674,6 +7637,8 @@ var leanbase = (function () {
         }));
         this.isLoaded = true;
         this.persistence = new LeanbasePersistence(this.config);
+        // Browser SDK always has a requestRouter; session replay relies on it for $snapshot ingestion URLs.
+        this.requestRouter = new RequestRouter(this);
         if (this.config.cookieless_mode !== 'always') {
           this.sessionManager = new SessionIdManager(this);
           this.sessionPropsManager = new SessionPropsManager(this, this.sessionManager, this.persistence);