@leanbase-giangnd/js 0.0.7 → 0.1.1

package/src/types.ts

@@ -1,5 +1,6 @@
 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,10 +102,14 @@ export interface LeanbaseConfig extends Partial<PostHogCoreOptions> {
      */
     host?: string
     /**
-     * Backwards-compatible alias expected by replay code
+     * API host (alias) used by some modules; kept for compatibility with upstream
      */
-    api_host: string
-    ui_host?: string | null
+    api_host?: string
+
+    /**
+     * UI host override
+     */
+    ui_host?: string
 
     /**
      * The token for your Leanbase project.
@@ -127,6 +132,22 @@ 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:
@@ -138,6 +159,11 @@ 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.
@@ -193,26 +219,6 @@ 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.
      *
@@ -355,15 +361,81 @@ 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
     /**
-     * Hook to allow preparing external dependency stylesheet before injection
+     * Force-enable session recording locally even if remote config disables it.
+     * Useful for dev/testing when the backend has sessionRecording set to false.
      */
-    prepare_external_dependency_stylesheet?: (stylesheet: HTMLStyleElement) => HTMLStyleElement | null | undefined
+    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
 }
 
-// Backwards-compatible alias expected by replay code
-export type PostHogConfig = LeanbaseConfig
+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'
+}
 
 export interface RageclickConfig {
     /**
@@ -499,6 +571,11 @@ export interface RemoteConfig {
      */
     autocaptureExceptions?: boolean | { endpoint?: string }
 
+    /**
+     * Session recording configuration options
+     */
+    sessionRecording?: SessionRecordingRemoteConfig | false
+
     /**
      * @deprecated, moved to toolbarParams
      */
@@ -509,11 +586,6 @@ export interface RemoteConfig {
      */
     isAuthenticated: boolean
 
-    /**
-     * Session recording remote config (when available)
-     */
-    sessionRecording?: SessionRecordingRemoteConfig
-
     /**
      * List of site apps with their IDs and URLs
      */
@@ -604,34 +676,16 @@ 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-hint'
+    | 'early-hints'
     | 'embed'
     | 'fetch'
     | 'frame'
     | 'iframe'
-    | 'icon'
     | 'image'
     | 'img'
     | 'input'
@@ -644,8 +698,24 @@ export type InitiatorType =
     | 'video'
     | 'xmlhttprequest'
 
-// we mirror PerformanceEntry since we read into this type from a PerformanceObserver,
-// but we don't want to inherit its readonly-iness
+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>
+
 type Writable<T> = { -readonly [P in keyof T]: T[P] }
 
 export type CapturedNetworkRequest = Writable<Omit<PerformanceEntry, 'toJSON'>> & {
@@ -660,35 +730,14 @@ 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 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 = {
+export interface SessionRecordingUrlTrigger {
     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'
@@ -699,47 +748,11 @@ export type SessionStartReason =
     | 'url_trigger_matched'
     | 'event_trigger_matched'
 
-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 SessionIdChangedCallback = (
+    sessionId: string,
+    windowId: string | null | undefined,
+    changeReason?: { noSessionId: boolean; activityTimeout: boolean; sessionPastMaximumLength: boolean }
+) => void
 
 export type LeanbasegCaptureOptions = {
     /** If provided overrides the auto-generated event ID */

package/src/utils/logger.ts

@@ -1,64 +1,26 @@
-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'
+import { logger as baseLogger } from '../leanbase-logger'
 
-type PosthogJsLogger = Omit<Logger, 'createLogger'> & {
-    _log: (level: 'log' | 'warn' | 'error', ...args: any[]) => void
+export type PosthogJsLogger = {
+    info: (...args: any[]) => void
+    warn: (...args: any[]) => void
+    error: (...args: any[]) => void
+    critical: (...args: any[]) => void
     uninitializedWarning: (methodName: string) => void
     createLogger: (prefix: string) => PosthogJsLogger
 }
 
 const _createLogger = (prefix: string): PosthogJsLogger => {
-    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)
-        },
-
+    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),
         uninitializedWarning: (methodName: string) => {
-            logger.error(`You must initialize Leanbase before calling ${methodName}`)
+            baseLogger.error(prefix, `You must initialize Leanbase before calling ${methodName}`)
         },
-
         createLogger: (additionalPrefix: string) => _createLogger(`${prefix} ${additionalPrefix}`),
     }
-    return logger
 }
 
 export const logger = _createLogger('[Leanbase]')
-
-export const createLogger = logger.createLogger
-
-// Provide fallback leanbase logger methods for code that expects a simple logger
-export const fallbackLogger = leanbaseLogger
+export const createLogger = _createLogger

package/src/version.ts

@@ -1 +1 @@
-export const version = '0.0.7'
+export const version = '0.1.1'

package/src/extensions/replay/external/README.md

@@ -1,5 +0,0 @@
-files in here are intended for the lazy loaded portion of replay
-
-you aren't supposed to import them from outside the entrypoint file
-
-they could cause an increase in bundle size

package/src/extensions/utils/stylesheet-loader.ts

@@ -1,27 +0,0 @@
-import { PostHog } from '../../posthog-core'
-import { createLogger } from '../../utils/logger'
-import { isUndefined, isNull } from '@posthog/core'
-
-const logger = createLogger('[Stylesheet Loader]')
-
-export const prepareStylesheet = (document: Document, innerText: string, posthog?: PostHog) => {
-    // Forcing the existence of `document` requires this function to be called in a browser environment
-    let stylesheet: HTMLStyleElement | null = document.createElement('style')
-    stylesheet.innerText = innerText
-
-    if (posthog?.config?.prepare_external_dependency_stylesheet) {
-        const result = posthog.config.prepare_external_dependency_stylesheet(stylesheet)
-        if (!isUndefined(result) && !isNull(result)) {
-            stylesheet = result
-        } else {
-            stylesheet = null
-        }
-    }
-
-    if (!stylesheet) {
-        logger.error('prepare_external_dependency_stylesheet returned null')
-        return null
-    }
-
-    return stylesheet
-}

package/src/posthog-core.ts

@@ -1,12 +0,0 @@
-import type { Leanbase } from './leanbase'
-
-// PostHog shim: Leanbase runtime with a widened onFeatureFlags signature
-export type PostHog = Leanbase & {
-    onFeatureFlags?: (cb: (...args: any[]) => void) => () => void
-    consent?: {
-        isOptedOut?: () => boolean
-    }
-}
-
-export { default as Config } from './config'
-export { logger } from './utils/logger'