@leanbase-giangnd/js 0.0.4 → 0.0.7

package/src/types.ts

@@ -1,6 +1,5 @@
 import { FeatureFlagValue, JsonType, PostHogCoreOptions } from '@posthog/core'
 import { KnownUnsafeEditableEvent } from '@posthog/core'
-import type { recordOptions } from './extensions/replay/types/rrweb'
 import { Leanbase } from './leanbase'
 
 export const COPY_AUTOCAPTURE_EVENT = '$copy_autocapture'
@@ -101,6 +100,11 @@ export interface LeanbaseConfig extends Partial<PostHogCoreOptions> {
      * @default 'https://i.leanbase.co'
      */
     host?: string
+    /**
+     * Backwards-compatible alias expected by replay code
+     */
+    api_host: string
+    ui_host?: string | null
 
     /**
      * The token for your Leanbase project.
@@ -123,22 +127,6 @@ export interface LeanbaseConfig extends Partial<PostHogCoreOptions> {
      */
     autocapture: boolean | AutocaptureConfig
 
-    /**
-     * Enables or disables session recording. When true, session recording is disabled on the client.
-     * @default false
-     */
-    disable_session_recording?: boolean
-
-    /**
-     * Session recording configuration
-     */
-    session_recording?: SessionRecordingOptions
-
-    /**
-     * Enable console.log recording for session replay (can be controlled remotely). Undefined defers to server.
-     */
-    enable_recording_console_log?: boolean
-
     /**
      * Determines whether Leanbase should capture pageview events automatically.
      * Can be:
@@ -150,11 +138,6 @@ export interface LeanbaseConfig extends Partial<PostHogCoreOptions> {
      */
     capture_pageview: boolean | 'history_change'
 
-    /**
-     * Enables performance capture. When true, network performance timing can be forwarded to replay when enabled.
-     */
-    capture_performance?: boolean | { network_timing?: boolean }
-
     /**
      * Determines the session idle timeout in seconds.
      * Any new event that's happened after this timeout will create a new session.
@@ -210,6 +193,26 @@ export interface LeanbaseConfig extends Partial<PostHogCoreOptions> {
      */
     persistence_name: string
 
+    /**
+     * Session recording options (browser parity)
+     */
+    session_recording: SessionRecordingOptions
+
+    /**
+     * Backwards-compatible flag to disable session recording
+     */
+    disable_session_recording?: boolean
+
+    /**
+     * Controls performance capture options used by replay/network tracing
+     */
+    capture_performance?: boolean | { network_timing?: boolean; web_vitals?: boolean }
+
+    /**
+     * Enable recording of console logs for session replay
+     */
+    enable_recording_console_log?: boolean
+
     /**
      * Prevent autocapture from capturing any attribute names on elements.
      *
@@ -352,81 +355,15 @@ export interface LeanbaseConfig extends Partial<PostHogCoreOptions> {
      * @param instance - The Leanbase instance that has been loaded.
      */
     loaded: (instance: Leanbase) => void
-}
 
-export type SessionRecordingCanvasOptions = {
-    recordCanvas?: boolean | null
-    canvasFps?: number | null
-    canvasQuality?: string | null
-}
-
-export interface SessionRecordingOptions {
-    blockClass?: string | RegExp
-    blockSelector?: string | null
-    ignoreClass?: string | RegExp
-    maskTextClass?: string | RegExp
-    maskTextSelector?: string | null
-    maskTextFn?: ((text: string, element?: HTMLElement) => string) | null
-    maskAllInputs?: boolean
-    maskInputOptions?: recordOptions['maskInputOptions']
-    maskInputFn?: ((text: string, element?: HTMLElement) => string) | null
-    slimDOMOptions?: recordOptions['slimDOMOptions']
-    collectFonts?: boolean
-    inlineStylesheet?: boolean
-    recordCrossOriginIframes?: boolean
-    recordHeaders?: boolean
-    recordBody?: boolean
-    captureCanvas?: SessionRecordingCanvasOptions
-    maskCapturedNetworkRequestFn?: ((data: CapturedNetworkRequest) => CapturedNetworkRequest | null | undefined) | null
-    maskNetworkRequestFn?: ((data: NetworkRequest) => NetworkRequest | null | undefined) | null
-    full_snapshot_interval_millis?: number
-    compress_events?: boolean
-    session_idle_threshold_ms?: number
-    __mutationThrottlerRefillRate?: number
-    __mutationThrottlerBucketSize?: number
     /**
-     * Force-enable session recording locally even if remote config disables it.
-     * Useful for dev/testing when the backend has sessionRecording set to false.
+     * Hook to allow preparing external dependency stylesheet before injection
      */
-    forceClientRecording?: boolean
-}
-
-export type SessionRecordingPersistedConfig = Omit<
-    SessionRecordingRemoteConfig,
-    | 'recordCanvas'
-    | 'canvasFps'
-    | 'canvasQuality'
-    | 'networkPayloadCapture'
-    | 'sampleRate'
-    | 'minimumDurationMilliseconds'
-> & {
-    enabled: boolean
-    networkPayloadCapture: SessionRecordingRemoteConfig['networkPayloadCapture'] & {
-        capturePerformance: RemoteConfig['capturePerformance']
-    }
-    canvasRecording: {
-        enabled: SessionRecordingRemoteConfig['recordCanvas']
-        fps: SessionRecordingRemoteConfig['canvasFps']
-        quality: SessionRecordingRemoteConfig['canvasQuality']
-    }
-    sampleRate: number | null
-    minimumDurationMilliseconds: number | null | undefined
+    prepare_external_dependency_stylesheet?: (stylesheet: HTMLStyleElement) => HTMLStyleElement | null | undefined
 }
 
-export type SessionRecordingRemoteConfig = SessionRecordingCanvasOptions & {
-    endpoint?: string
-    consoleLogRecordingEnabled?: boolean
-    sampleRate?: string | null
-    minimumDurationMilliseconds?: number
-    linkedFlag?: string | { flag: string; variant: string } | null
-    networkPayloadCapture?: Pick<NetworkRecordOptions, 'recordBody' | 'recordHeaders' | 'payloadHostDenyList'>
-    masking?: Pick<SessionRecordingOptions, 'maskAllInputs' | 'maskTextSelector' | 'blockSelector'>
-    urlTriggers?: SessionRecordingUrlTrigger[]
-    scriptConfig?: { script?: string | undefined }
-    urlBlocklist?: SessionRecordingUrlTrigger[]
-    eventTriggers?: string[]
-    triggerMatchType?: 'any' | 'all'
-}
+// Backwards-compatible alias expected by replay code
+export type PostHogConfig = LeanbaseConfig
 
 export interface RageclickConfig {
     /**
@@ -562,11 +499,6 @@ export interface RemoteConfig {
      */
     autocaptureExceptions?: boolean | { endpoint?: string }
 
-    /**
-     * Session recording configuration options
-     */
-    sessionRecording?: SessionRecordingRemoteConfig | false
-
     /**
      * @deprecated, moved to toolbarParams
      */
@@ -577,6 +509,11 @@ export interface RemoteConfig {
      */
     isAuthenticated: boolean
 
+    /**
+     * Session recording remote config (when available)
+     */
+    sessionRecording?: SessionRecordingRemoteConfig
+
     /**
      * List of site apps with their IDs and URLs
      */
@@ -667,16 +604,34 @@ export interface RequestWithOptions {
     }
 }
 
+export type DeadClicksAutoCaptureConfig = {
+    scroll_threshold_ms?: number
+    selection_change_threshold_ms?: number
+    mutation_threshold_ms?: number
+    __onCapture?: ((click: any, properties: Properties) => void) | undefined
+} & Pick<AutocaptureConfig, 'element_attribute_ignorelist'>
+
+export type ExternalIntegrationKind = 'intercom' | 'crispChat'
+
+export type SiteAppLoader = {
+    id: string
+    init: (config: { posthog: any; callback: (success: boolean) => void }) => {
+        processEvent?: (globals: any) => void
+    }
+}
+
+// Network / replay types (copied from browser package) -------------------------------------------------
 export type InitiatorType =
     | 'audio'
     | 'beacon'
     | 'body'
     | 'css'
-    | 'early-hints'
+    | 'early-hint'
     | 'embed'
     | 'fetch'
     | 'frame'
     | 'iframe'
+    | 'icon'
     | 'image'
     | 'img'
     | 'input'
@@ -689,24 +644,8 @@ export type InitiatorType =
     | 'video'
     | 'xmlhttprequest'
 
-export type NetworkRecordOptions = {
-    initiatorTypes?: InitiatorType[]
-    maskRequestFn?: (data: CapturedNetworkRequest) => CapturedNetworkRequest | undefined
-    recordHeaders?: boolean | { request: boolean; response: boolean }
-    recordBody?: boolean | string[] | { request: boolean | string[]; response: boolean | string[] }
-    recordInitialRequests?: boolean
-    recordPerformance?: boolean
-    performanceEntryTypeToObserve: string[]
-    payloadSizeLimitBytes: number
-    payloadHostDenyList?: string[]
-}
-
-export type NetworkRequest = {
-    url: string
-}
-
-export type Headers = Record<string, any>
-
+// we mirror PerformanceEntry since we read into this type from a PerformanceObserver,
+// but we don't want to inherit its readonly-iness
 type Writable<T> = { -readonly [P in keyof T]: T[P] }
 
 export type CapturedNetworkRequest = Writable<Omit<PerformanceEntry, 'toJSON'>> & {
@@ -721,14 +660,35 @@ export type CapturedNetworkRequest = Writable<Omit<PerformanceEntry, 'toJSON'>>
     requestBody?: string | null
     responseHeaders?: Headers
     responseBody?: string | null
+    // was this captured before fetch/xhr could have been wrapped
     isInitial?: boolean
 }
 
-export interface SessionRecordingUrlTrigger {
+export type Headers = Record<string, string>
+
+export type NetworkRecordOptions = {
+    initiatorTypes?: InitiatorType[]
+    maskRequestFn?: (data: CapturedNetworkRequest) => CapturedNetworkRequest | undefined
+    recordHeaders?: boolean | { request: boolean; response: boolean }
+    recordBody?: boolean | string[] | { request: boolean | string[]; response: boolean | string[] }
+    recordInitialRequests?: boolean
+    recordPerformance?: boolean
+    performanceEntryTypeToObserve: string[]
+    payloadSizeLimitBytes: number
+    payloadHostDenyList?: string[]
+}
+
+/** @deprecated - use CapturedNetworkRequest instead  */
+export type NetworkRequest = {
     url: string
-    matching: 'regex'
 }
 
+export type SessionIdChangedCallback = (
+    sessionId: string,
+    windowId: string | null | undefined,
+    changeReason?: { noSessionId: boolean; activityTimeout: boolean; sessionPastMaximumLength: boolean }
+) => void
+
 export type SessionStartReason =
     | 'sampling_overridden'
     | 'recording_initialized'
@@ -739,11 +699,47 @@ export type SessionStartReason =
     | 'url_trigger_matched'
     | 'event_trigger_matched'
 
-export type SessionIdChangedCallback = (
-    sessionId: string,
-    windowId: string | null | undefined,
-    changeReason?: { noSessionId: boolean; activityTimeout: boolean; sessionPastMaximumLength: boolean }
-) => void
+export type SessionRecordingCanvasOptions = {
+    recordCanvas?: boolean | null
+    canvasFps?: number | null
+    canvasQuality?: string | null
+}
+
+export type SessionRecordingOptions = {
+    __mutationThrottlerBucketSize?: number
+    __mutationThrottlerRefillRate?: number
+    blockClass?: string | RegExp
+    blockSelector?: string | null
+    captureCanvas?: SessionRecordingCanvasOptions
+    collectFonts?: boolean
+    compress_events?: boolean
+    full_snapshot_interval_millis?: number
+    ignoreClass?: string | RegExp
+    inlineStylesheet?: boolean
+    maskAllInputs?: boolean
+    maskCapturedNetworkRequestFn?: ((data: CapturedNetworkRequest) => CapturedNetworkRequest | null | undefined) | null
+    maskInputFn?: ((text: string, element?: HTMLElement) => string) | null
+    maskInputOptions?: any
+    maskNetworkRequestFn?: ((data: NetworkRequest) => NetworkRequest | null | undefined) | null
+    maskTextClass?: string | RegExp
+    maskTextFn?: ((text: string, element?: HTMLElement) => string) | null
+    maskTextSelector?: string | null
+    recordBody?: boolean
+    recordCrossOriginIframes?: boolean
+    recordHeaders?: boolean
+    session_idle_threshold_ms?: number
+    slimDOMOptions?: any
+}
+
+export type SessionRecordingPersistedConfig = any
+export type SessionRecordingRemoteConfig = any
+
+export type FlagVariant = { flag: string; variant: string }
+
+export interface SessionRecordingUrlTrigger {
+    url: string
+    matching: 'regex'
+}
 
 export type LeanbasegCaptureOptions = {
     /** If provided overrides the auto-generated event ID */

package/src/utils/globals.ts

@@ -0,0 +1,239 @@
+import type { PostHog } from '../posthog-core'
+import { SessionIdManager } from '../sessionid'
+import {
+    DeadClicksAutoCaptureConfig,
+    ExternalIntegrationKind,
+    Properties,
+    RemoteConfig,
+    SiteAppLoader,
+    SessionStartReason,
+} from '../types'
+// only importing types here, so won't affect the bundle
+// eslint-disable-next-line posthog-js/no-external-replay-imports
+import type { SessionRecordingStatus, TriggerType } from '../extensions/replay/external/triggerMatching'
+import { eventWithTime } from '../extensions/replay/types/rrweb-types'
+import { ErrorTracking } from '@posthog/core'
+
+/*
+ * Global helpers to protect access to browser globals in a way that is safer for different targets
+ * like DOM, SSR, Web workers etc.
+ *
+ * NOTE: Typically we want the "window" but globalThis works for both the typical browser context as
+ * well as other contexts such as the web worker context. Window is still exported for any bits that explicitly require it.
+ * If in doubt - export the global you need from this file and use that as an optional value. This way the code path is forced
+ * to handle the case where the global is not available.
+ */
+
+// eslint-disable-next-line no-restricted-globals
+const win: (Window & typeof globalThis) | undefined = typeof window !== 'undefined' ? window : undefined
+
+export type AssignableWindow = Window &
+    typeof globalThis & {
+        /*
+         * Main PostHog instance
+         */
+        posthog: any
+
+        /*
+         * This is our contract between (potentially) lazily loaded extensions and the SDK
+         */
+        __PosthogExtensions__?: PostHogExtensions
+
+        /**
+         * When loading remote config, we assign it to this global configuration
+         * for ease of sharing it with the rest of the SDK
+         */
+        _POSTHOG_REMOTE_CONFIG?: Record<
+            string,
+            {
+                config: RemoteConfig
+                siteApps: SiteAppLoader[]
+            }
+        >
+
+        /**
+         * If this is set on the window, our logger will log to the console
+         * for ease of debugging. Used for testing purposes only.
+         *
+         * @see {Config.DEBUG} from config.ts
+         */
+        POSTHOG_DEBUG: any
+
+        // Exposed by the browser
+        doNotTrack: any
+
+        // See entrypoints/customizations.full.ts
+        posthogCustomizations: any
+
+        /**
+         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
+         * Can be removed once we drop support for 1.161.1
+         *
+         * See entrypoints/exception-autocapture.ts
+         *
+         * @deprecated use `__PosthogExtensions__.errorWrappingFunctions` instead
+         */
+        posthogErrorWrappingFunctions: any
+
+        /**
+         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
+         * Can be removed once we drop support for 1.161.1
+         *
+         * See entrypoints/posthog-recorder.ts
+         *
+         * @deprecated use `__PosthogExtensions__.rrweb` instead
+         */
+        rrweb: any
+
+        /**
+         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
+         * Can be removed once we drop support for 1.161.1
+         *
+         * See entrypoints/posthog-recorder.ts
+         *
+         * @deprecated use `__PosthogExtensions__.rrwebConsoleRecord` instead
+         */
+        rrwebConsoleRecord: any
+
+        /**
+         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
+         * Can be removed once we drop support for 1.161.1
+         *
+         * See entrypoints/posthog-recorder.ts
+         *
+         * @deprecated use `__PosthogExtensions__.getRecordNetworkPlugin` instead
+         */
+        getRecordNetworkPlugin: any
+
+        /**
+         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
+         * Can be removed once we drop support for 1.161.1
+         *
+         * See entrypoints/web-vitals.ts
+         *
+         * @deprecated use `__PosthogExtensions__.postHogWebVitalsCallbacks` instead
+         */
+        postHogWebVitalsCallbacks: any
+
+        /**
+         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
+         * Can be removed once we drop support for 1.161.1
+         *
+         * See entrypoints/tracing-headers.ts
+         *
+         * @deprecated use `__PosthogExtensions__.postHogTracingHeadersPatchFns` instead
+         */
+        postHogTracingHeadersPatchFns: any
+
+        /**
+         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
+         * Can be removed once we drop support for 1.161.1
+         *
+         * See entrypoints/surveys.ts
+         *
+         * @deprecated use `__PosthogExtensions__.generateSurveys` instead
+         */
+        extendPostHogWithSurveys: any
+
+        /*
+         * These are used to handle our toolbar state.
+         * @see {Toolbar} from extensions/toolbar.ts
+         */
+        ph_load_toolbar: any
+        ph_load_editor: any
+        ph_toolbar_state: any
+    } & Record<`__$$ph_site_app_${string}`, any>
+
+/**
+ * This is our contract between (potentially) lazily loaded extensions and the SDK
+ * changes to this interface can be breaking changes for users of the SDK
+ */
+
+export type ExternalExtensionKind = 'intercom-integration' | 'crisp-chat-integration'
+
+export type PostHogExtensionKind =
+    | 'toolbar'
+    | 'exception-autocapture'
+    | 'web-vitals'
+    | 'recorder'
+    | 'lazy-recorder'
+    | 'tracing-headers'
+    | 'surveys'
+    | 'dead-clicks-autocapture'
+    | 'remote-config'
+    | ExternalExtensionKind
+
+export interface LazyLoadedSessionRecordingInterface {
+    start: (startReason?: SessionStartReason) => void
+    stop: () => void
+    sessionId: string
+    status: SessionRecordingStatus
+    onRRwebEmit: (rawEvent: eventWithTime) => void
+    log: (message: string, level: 'log' | 'warn' | 'error') => void
+    sdkDebugProperties: Properties
+    overrideLinkedFlag: () => void
+    overrideSampling: () => void
+    overrideTrigger: (triggerType: TriggerType) => void
+    isStarted: boolean
+    tryAddCustomEvent(tag: string, payload: any): boolean
+}
+
+export interface LazyLoadedDeadClicksAutocaptureInterface {
+    start: (observerTarget: Node) => void
+    stop: () => void
+}
+
+interface PostHogExtensions {
+    loadExternalDependency?: (
+        posthog: PostHog,
+        kind: PostHogExtensionKind,
+        callback: (error?: string | Event, event?: Event) => void
+    ) => void
+
+    loadSiteApp?: (posthog: PostHog, appUrl: string, callback: (error?: string | Event, event?: Event) => void) => void
+
+    errorWrappingFunctions?: {
+        wrapOnError: (captureFn: (props: ErrorTracking.ErrorProperties) => void) => () => void
+        wrapUnhandledRejection: (captureFn: (props: ErrorTracking.ErrorProperties) => void) => () => void
+        wrapConsoleError: (captureFn: (props: ErrorTracking.ErrorProperties) => void) => () => void
+    }
+    rrweb?: { record: any; version: string }
+    rrwebPlugins?: { getRecordConsolePlugin: any; getRecordNetworkPlugin?: any }
+    generateSurveys?: (posthog: PostHog, isSurveysEnabled: boolean) => any | undefined
+    postHogWebVitalsCallbacks?: {
+        onLCP: (metric: any) => void
+        onCLS: (metric: any) => void
+        onFCP: (metric: any) => void
+        onINP: (metric: any) => void
+    }
+    tracingHeadersPatchFns?: {
+        _patchFetch: (hostnames: string[], distinctId: string, sessionManager?: SessionIdManager) => () => void
+        _patchXHR: (hostnames: string[], distinctId: string, sessionManager?: SessionIdManager) => () => void
+    }
+    initDeadClicksAutocapture?: (
+        ph: PostHog,
+        config: DeadClicksAutoCaptureConfig
+    ) => LazyLoadedDeadClicksAutocaptureInterface
+    integrations?: {
+        [K in ExternalIntegrationKind]?: { start: (posthog: PostHog) => void; stop: () => void }
+    }
+    initSessionRecording?: (ph: PostHog) => LazyLoadedSessionRecordingInterface
+}
+
+const global: typeof globalThis | undefined = typeof globalThis !== 'undefined' ? globalThis : win
+
+export const ArrayProto = Array.prototype
+export const nativeForEach = ArrayProto.forEach
+export const nativeIndexOf = ArrayProto.indexOf
+
+export const navigator = global?.navigator
+export const document = global?.document
+export const location = global?.location
+export const fetch = global?.fetch
+export const XMLHttpRequest =
+    global?.XMLHttpRequest && 'withCredentials' in new global.XMLHttpRequest() ? global.XMLHttpRequest : undefined
+export const AbortController = global?.AbortController
+export const userAgent = navigator?.userAgent
+export const assignableWindow: AssignableWindow = win ?? ({} as any)
+
+export { win as window }

package/src/utils/logger.ts

@@ -1,26 +1,64 @@
-import { logger as baseLogger } from '../leanbase-logger'
+import Config from '../config'
+import { isUndefined } from '@posthog/core'
+import { assignableWindow, window } from './globals'
+import { logger as leanbaseLogger } from '../leanbase-logger'
+import type { Logger } from '@posthog/core'
 
-export type PosthogJsLogger = {
-    info: (...args: any[]) => void
-    warn: (...args: any[]) => void
-    error: (...args: any[]) => void
-    critical: (...args: any[]) => void
+type PosthogJsLogger = Omit<Logger, 'createLogger'> & {
+    _log: (level: 'log' | 'warn' | 'error', ...args: any[]) => void
     uninitializedWarning: (methodName: string) => void
     createLogger: (prefix: string) => PosthogJsLogger
 }
 
 const _createLogger = (prefix: string): PosthogJsLogger => {
-    return {
-        info: (...args: any[]) => baseLogger.info(prefix, ...args),
-        warn: (...args: any[]) => baseLogger.warn(prefix, ...args),
-        error: (...args: any[]) => baseLogger.error(prefix, ...args),
-        critical: (...args: any[]) => baseLogger.critical(prefix, ...args),
+    const logger: PosthogJsLogger = {
+        _log: (level: 'log' | 'warn' | 'error', ...args: any[]) => {
+            if (
+                window &&
+                (Config.DEBUG || assignableWindow.POSTHOG_DEBUG) &&
+                !isUndefined(window.console) &&
+                window.console
+            ) {
+                const consoleLog =
+                    '__rrweb_original__' in window.console[level]
+                        ? (window.console[level] as any)['__rrweb_original__']
+                        : window.console[level]
+
+                // eslint-disable-next-line no-console
+                consoleLog(prefix, ...args)
+            }
+        },
+
+        info: (...args: any[]) => {
+            logger._log('log', ...args)
+        },
+
+        warn: (...args: any[]) => {
+            logger._log('warn', ...args)
+        },
+
+        error: (...args: any[]) => {
+            logger._log('error', ...args)
+        },
+
+        critical: (...args: any[]) => {
+            // Critical errors are always logged to the console
+            // eslint-disable-next-line no-console
+            console.error(prefix, ...args)
+        },
+
         uninitializedWarning: (methodName: string) => {
-            baseLogger.error(prefix, `You must initialize Leanbase before calling ${methodName}`)
+            logger.error(`You must initialize Leanbase before calling ${methodName}`)
         },
+
         createLogger: (additionalPrefix: string) => _createLogger(`${prefix} ${additionalPrefix}`),
     }
+    return logger
 }
 
 export const logger = _createLogger('[Leanbase]')
-export const createLogger = _createLogger
+
+export const createLogger = logger.createLogger
+
+// Provide fallback leanbase logger methods for code that expects a simple logger
+export const fallbackLogger = leanbaseLogger