@leanbase-giangnd/js 0.1.5 → 0.2.2

package/dist/index.d.ts

@@ -1406,6 +1406,7 @@ declare class SessionRecording$1 {
     private _clearRemoteConfig;
     onRemoteConfig(response: RemoteConfig$1): void;
     log(message: string, level?: 'log' | 'warn' | 'error'): void;
+    private get _scriptName();
     private _onScriptLoaded;
     /**
      * this is maintained on the public API only because it has always been on the public API
@@ -3824,7 +3825,7 @@ declare class SessionIdManager {
         changeReason: {
             noSessionId: boolean;
             activityTimeout: boolean;
-            sessionPastMaximumLength: any;
+            sessionPastMaximumLength: boolean;
         } | undefined;
         lastActivityTimestamp: number;
     };
@@ -4292,7 +4293,7 @@ declare class PostHogSurveys {
     private _isInitializingSurveys;
     private _surveyCallbacks;
     constructor(_instance: PostHog);
-    onRemoteConfig(response: RemoteConfig): any;
+    onRemoteConfig(response: RemoteConfig): void;
     reset(): void;
     loadIfEnabled(): void;
     /** Helper to finalize survey initialization */

package/dist/index.mjs

@@ -1,5 +1,4 @@
 import { isArray, isNullish, isFormData, hasOwnProperty, isString, isNull, isNumber, PostHogPersistedProperty, isUndefined, isFunction, includes, stripLeadingDollar, isObject, isEmptyObject, trim, isBoolean, clampToRange, BucketedRateLimiter, PostHogCore, getFetch, isEmptyString } from '@posthog/core';
-import { record } from '@rrweb/record';
 import { strFromU8, gzipSync, strToU8 } from 'fflate';
 
 const breaker = {};
@@ -15,6 +14,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 (isArray(obj)) {
     if (nativeForEach && obj.forEach === nativeForEach) {
@@ -1168,7 +1169,7 @@ const detectDeviceType = function (user_agent) {
   }
 };
 
-var version = "0.1.5";
+var version = "0.2.2";
 var packageInfo = {
 	version: version};
 
@@ -3106,12 +3107,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: rrwebRecordProxy
 };
 // Provide initSessionRecording if not present — return a new LazyLoadedSessionRecording when called
 _target.__PosthogExtensions__.initSessionRecording = _target.__PosthogExtensions__.initSessionRecording || (instance => {
@@ -3864,7 +3954,41 @@ function getRRWebRecord() {
   } catch {
     // ignore
   }
-  return 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 strFromU8(gzipSync(strToU8(JSON.stringify(data))), true);
@@ -4287,7 +4411,7 @@ class LazyLoadedSessionRecording {
     const parsedConfig = 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');
@@ -4321,7 +4445,7 @@ class LazyLoadedSessionRecording {
       });
     });
     this._makeSamplingDecision(this.sessionId);
-    this._startRecorder();
+    await this._startRecorder();
     // calling addEventListener multiple times is safe and will not add duplicates
     addEventListener(win, 'beforeunload', this._onBeforeUnload);
     addEventListener(win, 'offline', this._onOffline);
@@ -4777,7 +4901,7 @@ class LazyLoadedSessionRecording {
       $sdk_debug_session_start: sessionStartTimestamp
     };
   }
-  _startRecorder() {
+  async _startRecorder() {
     if (this._stopRrweb) {
       return;
     }
@@ -4833,7 +4957,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;
@@ -4875,6 +5004,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),
@@ -4943,6 +5073,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() {
@@ -5021,12 +5163,40 @@ 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) {
+        this._lazyLoadedSessionRecording = assignableWindow.__PosthogExtensions__?.initSessionRecording(this._instance);
+        this._lazyLoadedSessionRecording._forceAllowLocalhostNetworkCapture = this._forceAllowLocalhostNetworkCapture;
+      }
+      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