@leanbase-giangnd/js 0.0.7 → 0.1.1

package/src/extensions/replay/session-recording.ts

@@ -1,28 +1,29 @@
 import { SESSION_RECORDING_IS_SAMPLED, SESSION_RECORDING_REMOTE_CONFIG } from '../../constants'
-import { PostHog } from '../../posthog-core'
+import { Leanbase } from '../../leanbase'
 import { Properties, RemoteConfig, SessionRecordingPersistedConfig, SessionStartReason } from '../../types'
 import { type eventWithTime } from './types/rrweb-types'
 
 import { isNullish, isUndefined } from '@posthog/core'
-import { createLogger } from '../../utils/logger'
-import {
-    assignableWindow,
-    LazyLoadedSessionRecordingInterface,
-    PostHogExtensionKind,
-    window,
-} from '../../utils/globals'
+import { logger } from '../../leanbase-logger'
+import { window } from '../../utils'
+import { LazyLoadedSessionRecording } from './external/lazy-loaded-session-recorder'
 import { DISABLED, LAZY_LOADING, SessionRecordingStatus, TriggerType } from './external/triggerMatching'
 
 const LOGGER_PREFIX = '[SessionRecording]'
-const logger = createLogger(LOGGER_PREFIX)
+const log = {
+    info: (...args: any[]) => logger.info(LOGGER_PREFIX, ...args),
+    warn: (...args: any[]) => logger.warn(LOGGER_PREFIX, ...args),
+    error: (...args: any[]) => logger.error(LOGGER_PREFIX, ...args),
+}
 
 export class SessionRecording {
     _forceAllowLocalhostNetworkCapture: boolean = false
 
     private _receivedFlags: boolean = false
+    private _serverRecordingEnabled: boolean = false
 
     private _persistFlagsOnSessionListener: (() => void) | undefined = undefined
-    private _lazyLoadedSessionRecording: LazyLoadedSessionRecordingInterface | undefined
+    private _lazyLoadedSessionRecording: LazyLoadedSessionRecording | undefined
 
     public get started(): boolean {
         return !!this._lazyLoadedSessionRecording?.isStarted
@@ -44,9 +45,9 @@ export class SessionRecording {
         return LAZY_LOADING
     }
 
-    constructor(private readonly _instance: PostHog) {
+    constructor(private readonly _instance: Leanbase) {
         if (!this._instance.sessionManager) {
-            logger.error('started without valid sessionManager')
+            log.error('started without valid sessionManager')
             throw new Error(LOGGER_PREFIX + ' started without valid sessionManager. This is a bug.')
         }
 
@@ -58,7 +59,7 @@ export class SessionRecording {
     private get _isRecordingEnabled() {
         const enabled_server_side = !!this._instance.get_property(SESSION_RECORDING_REMOTE_CONFIG)?.enabled
         const enabled_client_side = !this._instance.config.disable_session_recording
-        const isDisabled = this._instance.config.disable_session_recording || !!this._instance.consent?.isOptedOut?.()
+        const isDisabled = this._instance.config.disable_session_recording || this._instance.consent?.isOptedOut?.()
         return window && enabled_server_side && enabled_client_side && !isDisabled
     }
 
@@ -67,17 +68,10 @@ export class SessionRecording {
             return
         }
 
-        // According to the rrweb docs, rrweb is not supported on IE11 and below:
-        // "rrweb does not support IE11 and below because it uses the MutationObserver API, which was supported by these browsers."
-        // https://github.com/rrweb-io/rrweb/blob/master/guide.md#compatibility-note
-        //
-        // However, MutationObserver does exist on IE11, it just doesn't work well and does not detect all changes.
-        // Instead, when we load "recorder.js", the first JS error is about "Object.assign" and "Array.from" being undefined.
-        // Thus instead of MutationObserver, we look for this function and block recording if it's undefined.
         const canRunReplay = !isUndefined(Object.assign) && !isUndefined(Array.from)
         if (this._isRecordingEnabled && canRunReplay) {
             this._lazyLoadAndStart(startReason)
-            logger.info('starting')
+            log.info('starting')
         } else {
             this.stopRecording()
         }
@@ -97,25 +91,7 @@ export class SessionRecording {
             return
         }
 
-        // If recorder.js is already loaded (if array.full.js snippet is used or posthog-js/dist/recorder is
-        // imported), don't load the script. Otherwise, remotely import recorder.js from cdn since it hasn't been loaded.
-        if (
-            !assignableWindow?.__PosthogExtensions__?.rrweb?.record ||
-            !assignableWindow.__PosthogExtensions__?.initSessionRecording
-        ) {
-            assignableWindow.__PosthogExtensions__?.loadExternalDependency?.(
-                this._instance,
-                this._scriptName,
-                (err) => {
-                    if (err) {
-                        return logger.error('could not load recorder', err)
-                    }
-                    this._onScriptLoaded(startReason)
-                }
-            )
-        } else {
-            this._onScriptLoaded(startReason)
-        }
+        this._onScriptLoaded(startReason)
     }
 
     stopRecording() {
@@ -179,20 +155,28 @@ export class SessionRecording {
         }
     }
 
+    private _clearRemoteConfig() {
+        this._instance.persistence?.unregister(SESSION_RECORDING_REMOTE_CONFIG)
+        this._resetSampling()
+    }
+
     onRemoteConfig(response: RemoteConfig) {
         if (!('sessionRecording' in response)) {
             // if sessionRecording is not in the response, we do nothing
-            logger.info('skipping remote config with no sessionRecording', response)
+            log.info('skipping remote config with no sessionRecording', response)
             return
         }
+        this._receivedFlags = true
+
         if (response.sessionRecording === false) {
-            // remotely disabled
-            this._receivedFlags = true
+            this._serverRecordingEnabled = false
+            this._clearRemoteConfig()
+            this.stopRecording()
             return
         }
 
+        this._serverRecordingEnabled = true
         this._persistRemoteConfig(response)
-        this._receivedFlags = true
         this.startIfEnabledOrStop()
     }
 
@@ -204,22 +188,9 @@ export class SessionRecording {
         }
     }
 
-    private get _scriptName(): PostHogExtensionKind {
-        const remoteConfig: SessionRecordingPersistedConfig | undefined = this._instance?.persistence?.get_property(
-            SESSION_RECORDING_REMOTE_CONFIG
-        )
-        return (remoteConfig?.scriptConfig?.script as PostHogExtensionKind) || 'lazy-recorder'
-    }
-
     private _onScriptLoaded(startReason?: SessionStartReason) {
-        if (!assignableWindow.__PosthogExtensions__?.initSessionRecording) {
-            throw Error('Called on script loaded before session recording is available')
-        }
-
         if (!this._lazyLoadedSessionRecording) {
-            this._lazyLoadedSessionRecording = assignableWindow.__PosthogExtensions__?.initSessionRecording(
-                this._instance
-            )
+            this._lazyLoadedSessionRecording = new LazyLoadedSessionRecording(this._instance)
             ;(this._lazyLoadedSessionRecording as any)._forceAllowLocalhostNetworkCapture =
                 this._forceAllowLocalhostNetworkCapture
         }

package/src/leanbase.ts

@@ -7,7 +7,6 @@ import {
     isObject,
     isString,
     isUndefined,
-    isFunction,
 } from '@posthog/core'
 import type {
     PostHogEventProperties,
@@ -39,18 +38,25 @@ import { COOKIELESS_MODE_FLAG_PROPERTY, USER_STATE } from './constants'
 import { getEventProperties } from './utils/event-utils'
 import { SessionIdManager } from './sessionid'
 import { SessionPropsManager } from './session-props'
-import { RequestRouter } from './utils/request-router'
 import { uuidv7 } from './uuidv7'
 import { PageViewManager } from './page-view'
 import { ScrollManager } from './scroll-manager'
 import { isLikelyBot } from './utils/blocked-uas'
+import { SessionRecording } from './extensions/replay/session-recording'
+import type { RequestRouter } from '../../browser/lib/src/utils/request-router'
+import type { ConsentManager } from '../../browser/lib/src/consent'
 
 const defaultConfig = (): LeanbaseConfig => ({
     host: 'https://i.leanbase.co',
-    api_host: 'https://i.leanbase.co',
     token: '',
     autocapture: true,
     rageclick: true,
+    disable_session_recording: false,
+    session_recording: {
+        // Force-enable session recording locally unless explicitly disabled via config
+        forceClientRecording: true,
+    },
+    enable_recording_console_log: undefined,
     persistence: 'localStorage+cookie',
     capture_pageview: 'history_change',
     capture_pageleave: 'if_capture_pageview',
@@ -71,7 +77,6 @@ const defaultConfig = (): LeanbaseConfig => ({
     opt_out_useragent_filter: false,
     properties_string_max_length: 65535,
     loaded: () => {},
-    session_recording: {} as any,
 })
 
 export class Leanbase extends PostHogCore {
@@ -84,8 +89,9 @@ export class Leanbase extends PostHogCore {
     sessionPersistence?: LeanbasePersistence
     sessionManager?: SessionIdManager
     sessionPropsManager?: SessionPropsManager
-    sessionRecording?: any
-    requestRouter: RequestRouter
+    requestRouter!: RequestRouter
+    consent!: ConsentManager
+    sessionRecording?: SessionRecording
     isRemoteConfigLoaded?: boolean
     personProcessingSetOncePropertiesSent = false
     isLoaded: boolean = false
@@ -102,7 +108,6 @@ export class Leanbase extends PostHogCore {
         this.initialPageviewCaptured = false
         this.scrollManager = new ScrollManager(this)
         this.pageViewManager = new PageViewManager(this)
-        this.requestRouter = new RequestRouter(this)
         this.init(token, mergedConfig)
     }
 
@@ -114,19 +119,16 @@ export class Leanbase extends PostHogCore {
         )
         this.isLoaded = true
         this.persistence = new LeanbasePersistence(this.config)
-        this.replayAutocapture = new Autocapture(this)
-        this.replayAutocapture.startIfEnabled()
 
-        // Initialize session manager and props before session recording (matches browser behavior)
         if (this.config.cookieless_mode !== 'always') {
-            if (!this.sessionManager) {
-                this.sessionManager = new SessionIdManager(this)
-                this.sessionPropsManager = new SessionPropsManager(this, this.sessionManager, this.persistence as any)
-            }
+            this.sessionManager = new SessionIdManager(this)
+            this.sessionPropsManager = new SessionPropsManager(this, this.sessionManager, this.persistence)
+        }
+
+        this.replayAutocapture = new Autocapture(this)
+        this.replayAutocapture.startIfEnabled()
 
-            // runtime require to lazy-load replay code; allowed for browser parity
-            // @ts-expect-error - runtime import only available in browser build
-            const { SessionRecording } = require('./extensions/replay/session-recording') // eslint-disable-line @typescript-eslint/no-require-imports
+        if (this.sessionManager && this.config.cookieless_mode !== 'always') {
             this.sessionRecording = new SessionRecording(this)
             this.sessionRecording.startIfEnabledOrStop()
         }
@@ -207,6 +209,7 @@ export class Leanbase extends PostHogCore {
 
         this.isRemoteConfigLoaded = true
         this.replayAutocapture?.onRemoteConfig(config)
+        this.sessionRecording?.onRemoteConfig(config)
     }
 
     fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse> {
@@ -222,8 +225,13 @@ export class Leanbase extends PostHogCore {
         const oldConfig = { ...this.config }
         if (isObject(config)) {
             extend(this.config, config)
+            if (!this.config.api_host && this.config.host) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ;(this.config as any).api_host = this.config.host
+            }
             this.persistence?.update_config(this.config, oldConfig)
             this.replayAutocapture?.startIfEnabled()
+            this.sessionRecording?.startIfEnabledOrStop()
         }
 
         const isTempStorage = this.config.persistence === 'sessionStorage' || this.config.persistence === 'memory'
@@ -248,43 +256,14 @@ export class Leanbase extends PostHogCore {
         return this.persistence?.get_property(key)
     }
 
-    setPersistedProperty<T>(key: PostHogPersistedProperty, value: T | null): void {
-        this.persistence?.set_property(key, value)
-    }
-
-    // Backwards-compatible aliases expected by replay/browser code
-    get_property(key: string): any {
+    get_property<T = any>(key: string): T | undefined {
         return this.persistence?.get_property(key)
     }
 
-    set_property(key: string, value: any): void {
+    setPersistedProperty<T>(key: PostHogPersistedProperty, value: T | null): void {
         this.persistence?.set_property(key, value)
     }
 
-    register_for_session(properties: Record<string, any>): void {
-        // PostHogCore may expose registerForSession; call it if available
-        if (isFunction((this as any).registerForSession)) {
-            ;(this as any).registerForSession(properties)
-            return
-        }
-
-        // fallback: store properties in sessionPersistence
-        if (this.sessionPersistence) {
-            Object.keys(properties).forEach((k) => this.sessionPersistence?.set_property(k, properties[k]))
-        }
-    }
-
-    unregister_for_session(property: string): void {
-        if (isFunction((this as any).unregisterForSession)) {
-            ;(this as any).unregisterForSession(property)
-            return
-        }
-
-        if (this.sessionPersistence) {
-            this.sessionPersistence.set_property(property, null)
-        }
-    }
-
     calculateEventProperties(
         eventName: string,
         eventProperties: PostHogEventProperties,
@@ -334,6 +313,14 @@ export class Leanbase extends PostHogCore {
             extend(properties, this.sessionPropsManager.getSessionProps())
         }
 
+        try {
+            if (this.sessionRecording) {
+                extend(properties, this.sessionRecording.sdkDebugProperties)
+            }
+        } catch (e: any) {
+            properties['$sdk_debug_error_capturing_properties'] = String(e)
+        }
+
         let pageviewProperties: Record<string, any> = this.pageViewManager.doEvent()
         if (eventName === '$pageview' && !readOnly) {
             pageviewProperties = this.pageViewManager.doPageView(timestamp, uuid)

package/src/types/fflate.d.ts

@@ -0,0 +1,5 @@
+declare module 'fflate' {
+    export const gzipSync: (...args: any[]) => any
+    export const strFromU8: (...args: any[]) => any
+    export const strToU8: (...args: any[]) => any
+}

package/src/types/rrweb-record.d.ts

@@ -0,0 +1,8 @@
+declare module '@rrweb/record' {
+    import type { recordOptions, rrwebRecord } from '../extensions/replay/types/rrweb'
+
+    const record: (options: recordOptions) => rrwebRecord
+
+    export { record }
+    export default record
+}