@leanbase.com/js 0.2.1 → 0.2.2-alpha.0

package/dist/extensions/replay/external/config.d.ts

@@ -0,0 +1,9 @@
+import { LeanbaseConfig, NetworkRecordOptions } from '../../../types';
+export declare const defaultNetworkOptions: Required<NetworkRecordOptions>;
+/**
+ *  whether a maskRequestFn is provided or not,
+ *  we ensure that we remove the denied header from requests
+ *  we _never_ want to record that header by accident
+ *  if someone complains then we'll add an opt-in to let them override it
+ */
+export declare const buildNetworkRequestOptions: (instanceConfig: LeanbaseConfig, remoteNetworkOptions?: Pick<NetworkRecordOptions, "recordHeaders" | "recordBody" | "recordPerformance" | "payloadHostDenyList">) => NetworkRecordOptions;

package/dist/extensions/replay/external/denylist.d.ts

@@ -0,0 +1,5 @@
+import { NetworkRecordOptions } from '../../../types';
+export declare function isHostOnDenyList(url: string | URL | Request, options: NetworkRecordOptions): {
+    hostname: string | null;
+    isHostDenied: boolean;
+};

package/dist/extensions/replay/external/lazy-loaded-session-recorder.d.ts

@@ -0,0 +1,153 @@
+import { EventType, eventWithTime, IncrementalSource } from '../types/rrweb-types';
+import { SessionRecordingStatus, TriggerType } from './triggerMatching';
+import { Leanbase } from '../../../leanbase';
+import { Properties, SessionRecordingPersistedConfig, SessionStartReason } from '../../../types';
+export declare const RECORDING_IDLE_THRESHOLD_MS: number;
+export declare const RECORDING_MAX_EVENT_SIZE: number;
+export declare const RECORDING_BUFFER_TIMEOUT = 2000;
+export declare const SESSION_RECORDING_BATCH_KEY = "recordings";
+export interface SnapshotBuffer {
+    size: number;
+    data: any[];
+    sessionId: string;
+    windowId: string;
+}
+export type compressedFullSnapshotEvent = {
+    type: EventType.FullSnapshot;
+    data: string;
+};
+export type compressedIncrementalSnapshotEvent = {
+    type: EventType.IncrementalSnapshot;
+    data: {
+        source: IncrementalSource;
+        texts: string;
+        attributes: string;
+        removes: string;
+        adds: string;
+    };
+};
+export type compressedIncrementalStyleSnapshotEvent = {
+    type: EventType.IncrementalSnapshot;
+    data: {
+        source: IncrementalSource.StyleSheetRule;
+        id?: number;
+        styleId?: number;
+        replace?: string;
+        replaceSync?: string;
+        adds?: string;
+        removes?: string;
+    };
+};
+export type compressedEvent = compressedIncrementalStyleSnapshotEvent | compressedFullSnapshotEvent | compressedIncrementalSnapshotEvent;
+export type compressedEventWithTime = compressedEvent & {
+    timestamp: number;
+    delay?: number;
+    cv: '2024-10';
+};
+export declare const SEVEN_MEGABYTES: number;
+export declare function splitBuffer(buffer: SnapshotBuffer, sizeLimit?: number): SnapshotBuffer[];
+export declare class LazyLoadedSessionRecording {
+    private readonly _instance;
+    private _endpoint;
+    private _mutationThrottler?;
+    /**
+     * Util to help developers working on this feature manually override
+     */
+    private _forceAllowLocalhostNetworkCapture;
+    private _stopRrweb;
+    private _lastActivityTimestamp;
+    /**
+     * if pageview capture is disabled,
+     * then we can manually track href changes
+     */
+    private _lastHref?;
+    /**
+     * and a queue - that contains rrweb events that we want to send to rrweb, but rrweb wasn't able to accept them yet
+     */
+    private _queuedRRWebEvents;
+    private _isIdle;
+    private _warnedMissingConsolePlugin;
+    private _linkedFlagMatching;
+    private _urlTriggerMatching;
+    private _eventTriggerMatching;
+    private _triggerMatching;
+    private _fullSnapshotTimer?;
+    private _windowId;
+    private _sessionId;
+    get sessionId(): string;
+    private _flushBufferTimer?;
+    private _buffer;
+    private _removePageViewCaptureHook;
+    private _removeEventTriggerCaptureHook;
+    private get _sessionManager();
+    private get _sessionIdleThresholdMilliseconds();
+    private get _isSampled();
+    private get _sampleRate();
+    private get _minimumDuration();
+    private _statusMatcher;
+    private _onSessionIdListener;
+    private _onSessionIdleResetForcedListener;
+    private _samplingSessionListener;
+    private _forceIdleSessionIdListener;
+    constructor(_instance: Leanbase);
+    private get _masking();
+    private get _canvasRecording();
+    private get _isConsoleLogCaptureEnabled();
+    private get _networkPayloadCapture();
+    private _gatherRRWebPlugins;
+    private _maskUrl;
+    private _tryRRWebMethod;
+    private _tryAddCustomEvent;
+    private _pageViewFallBack;
+    private _processQueuedEvents;
+    private _tryTakeFullSnapshot;
+    private get _fullSnapshotIntervalMillis();
+    private _scheduleFullSnapshot;
+    private _pauseRecording;
+    private _resumeRecording;
+    private _activateTrigger;
+    get isStarted(): boolean;
+    get _remoteConfig(): SessionRecordingPersistedConfig | undefined;
+    start(startReason?: SessionStartReason): void;
+    private _onSessionIdCallback;
+    stop(): void;
+    onRRwebEmit(rawEvent: eventWithTime): void;
+    get status(): SessionRecordingStatus;
+    log(message: string, level?: 'log' | 'warn' | 'error'): void;
+    overrideLinkedFlag(): void;
+    /**
+     * 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(): void;
+    /**
+     * 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: TriggerType): void;
+    private _clearFlushBufferTimer;
+    private _flushBuffer;
+    private _captureSnapshotBuffered;
+    private _captureSnapshot;
+    private _snapshotUrl;
+    private get _sessionDuration();
+    private _clearBufferBeforeMostRecentMeta;
+    private _clearBuffer;
+    private _onBeforeUnload;
+    private _onOffline;
+    private _onOnline;
+    private _onVisibilityChange;
+    private _reportStarted;
+    private _isInteractiveEvent;
+    private _updateWindowAndSessionIds;
+    private _clearConditionalRecordingPersistence;
+    private _makeSamplingDecision;
+    private _addEventTriggerListener;
+    get sdkDebugProperties(): Properties;
+    private _startRecorder;
+    tryAddCustomEvent(tag: string, payload: any): boolean;
+}

package/dist/extensions/replay/external/mutation-throttler.d.ts

@@ -0,0 +1,20 @@
+import type { eventWithTime } from '../types/rrweb-types';
+import type { rrwebRecord } from '../types/rrweb';
+export declare class MutationThrottler {
+    private readonly _rrweb;
+    private readonly _options;
+    private _loggedTracker;
+    private _rateLimiter;
+    constructor(_rrweb: rrwebRecord, _options?: {
+        bucketSize?: number;
+        refillRate?: number;
+        onBlockedNode?: (id: number, node: Node | null) => void;
+    });
+    private _onNodeRateLimited;
+    private _getNodeOrRelevantParent;
+    private _getNode;
+    private _numberOfChanges;
+    throttleMutations: (event: eventWithTime) => eventWithTime | undefined;
+    reset(): void;
+    stop(): void;
+}

package/dist/extensions/replay/external/network-plugin.d.ts

@@ -0,0 +1,15 @@
+import type { RecordPlugin } from '../types/rrweb-types';
+import { CapturedNetworkRequest, Headers, NetworkRecordOptions } from '../../../types';
+export type NetworkData = {
+    requests: CapturedNetworkRequest[];
+    isInitial?: boolean;
+};
+export declare function findLast<T>(array: Array<T>, predicate: (value: T) => boolean): T | undefined;
+export declare function shouldRecordBody({ type, recordBody, headers, url, }: {
+    type: 'request' | 'response';
+    headers: Headers;
+    url: string | URL | RequestInfo;
+    recordBody: NetworkRecordOptions['recordBody'];
+}): boolean;
+export declare const NETWORK_PLUGIN_NAME = "rrweb/network@1";
+export declare const getRecordNetworkPlugin: (options?: NetworkRecordOptions) => RecordPlugin;

package/dist/extensions/replay/external/sessionrecording-utils.d.ts

@@ -0,0 +1,19 @@
+import type { eventWithTime } from '../types/rrweb-types';
+import { SnapshotBuffer } from './lazy-loaded-session-recorder';
+export declare function circularReferenceReplacer(): (this: any, _key: string, value: any) => any;
+export declare function estimateSize(sizeable: unknown): number;
+export declare const replacementImageURI = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHZpZXdCb3g9IjAgMCAxNiAxNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHJlY3Qgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2IiBmaWxsPSJibGFjayIvPgo8cGF0aCBkPSJNOCAwSDE2TDAgMTZWOEw4IDBaIiBmaWxsPSIjMkQyRDJEIi8+CjxwYXRoIGQ9Ik0xNiA4VjE2SDhMMTYgOFoiIGZpbGw9IiMyRDJEMkQiLz4KPC9zdmc+Cg==";
+export declare const FULL_SNAPSHOT_EVENT_TYPE = 2;
+export declare const META_EVENT_TYPE = 4;
+export declare const INCREMENTAL_SNAPSHOT_EVENT_TYPE = 3;
+export declare const PLUGIN_EVENT_TYPE = 6;
+export declare const MUTATION_SOURCE_TYPE = 0;
+export declare const MAX_MESSAGE_SIZE = 5000000;
+export declare function ensureMaxMessageSize(data: eventWithTime): {
+    event: eventWithTime;
+    size: number;
+};
+export declare const CONSOLE_LOG_PLUGIN_NAME = "rrweb/console@1";
+export declare function truncateLargeConsoleLogs(_event: eventWithTime): eventWithTime;
+export declare const SEVEN_MEGABYTES: number;
+export declare function splitBuffer(buffer: SnapshotBuffer, sizeLimit?: number): SnapshotBuffer[];

package/dist/extensions/replay/external/triggerMatching.d.ts

@@ -0,0 +1,102 @@
+import { Leanbase } from '../../../leanbase';
+import { RemoteConfig, SessionRecordingPersistedConfig, SessionRecordingUrlTrigger } from '../../../types';
+export declare const DISABLED = "disabled";
+export declare const SAMPLED = "sampled";
+export declare const ACTIVE = "active";
+export declare const BUFFERING = "buffering";
+export declare const PAUSED = "paused";
+export declare const LAZY_LOADING = "lazy_loading";
+export declare const TRIGGER_ACTIVATED: string;
+export declare const TRIGGER_PENDING: string;
+export declare const TRIGGER_DISABLED: string;
+export interface RecordingTriggersStatus {
+    get receivedFlags(): boolean;
+    get isRecordingEnabled(): false | true | undefined;
+    get isSampled(): false | true | null;
+    get urlTriggerMatching(): URLTriggerMatching;
+    get eventTriggerMatching(): EventTriggerMatching;
+    get linkedFlagMatching(): LinkedFlagMatching;
+    get sessionId(): string;
+}
+export type TriggerType = 'url' | 'event';
+declare const triggerStatuses: readonly [string, string, string];
+export type TriggerStatus = (typeof triggerStatuses)[number];
+/**
+ * Session recording starts in buffering mode while waiting for "flags response".
+ * Once the response is received, it might be disabled, active or sampled.
+ * When "sampled" that means a sample rate is set, and the last time the session ID rotated
+ * the sample rate determined this session should be sent to the server.
+ */
+declare const sessionRecordingStatuses: readonly ["disabled", "sampled", "active", "buffering", "paused", "lazy_loading"];
+export type SessionRecordingStatus = (typeof sessionRecordingStatuses)[number];
+type ReplayConfigType = RemoteConfig | SessionRecordingPersistedConfig;
+export interface TriggerStatusMatching {
+    triggerStatus(sessionId: string): TriggerStatus;
+    stop(): void;
+}
+export declare class OrTriggerMatching implements TriggerStatusMatching {
+    private readonly _matchers;
+    constructor(_matchers: TriggerStatusMatching[]);
+    triggerStatus(sessionId: string): TriggerStatus;
+    stop(): void;
+}
+export declare class AndTriggerMatching implements TriggerStatusMatching {
+    private readonly _matchers;
+    constructor(_matchers: TriggerStatusMatching[]);
+    triggerStatus(sessionId: string): TriggerStatus;
+    stop(): void;
+}
+export declare class PendingTriggerMatching implements TriggerStatusMatching {
+    triggerStatus(): TriggerStatus;
+    stop(): void;
+}
+export declare class URLTriggerMatching implements TriggerStatusMatching {
+    private readonly _instance;
+    _urlTriggers: SessionRecordingUrlTrigger[];
+    _urlBlocklist: SessionRecordingUrlTrigger[];
+    urlBlocked: boolean;
+    constructor(_instance: Leanbase);
+    onConfig(config: ReplayConfigType): void;
+    /**
+     * @deprecated Use onConfig instead
+     */
+    onRemoteConfig(response: RemoteConfig): void;
+    private _urlTriggerStatus;
+    triggerStatus(sessionId: string): TriggerStatus;
+    checkUrlTriggerConditions(onPause: () => void, onResume: () => void, onActivate: (triggerType: TriggerType) => void): void;
+    stop(): void;
+}
+export declare class LinkedFlagMatching implements TriggerStatusMatching {
+    private readonly _instance;
+    linkedFlag: string | {
+        flag: string;
+        variant: string;
+    } | null;
+    linkedFlagSeen: boolean;
+    private _flagListenerCleanup;
+    constructor(_instance: Leanbase);
+    triggerStatus(): TriggerStatus;
+    onConfig(config: ReplayConfigType, onStarted: (flag: string, variant: string | null) => void): void;
+    /**
+     * @deprecated Use onConfig instead
+     */
+    onRemoteConfig(response: RemoteConfig, onStarted: (flag: string, variant: string | null) => void): void;
+    stop(): void;
+}
+export declare class EventTriggerMatching implements TriggerStatusMatching {
+    private readonly _instance;
+    _eventTriggers: string[];
+    constructor(_instance: Leanbase);
+    onConfig(config: ReplayConfigType): void;
+    /**
+     * @deprecated Use onConfig instead
+     */
+    onRemoteConfig(response: RemoteConfig): void;
+    private _eventTriggerStatus;
+    triggerStatus(sessionId: string): TriggerStatus;
+    stop(): void;
+}
+export declare function nullMatchSessionRecordingStatus(triggersStatus: RecordingTriggersStatus): SessionRecordingStatus;
+export declare function anyMatchSessionRecordingStatus(triggersStatus: RecordingTriggersStatus): SessionRecordingStatus;
+export declare function allMatchSessionRecordingStatus(triggersStatus: RecordingTriggersStatus): SessionRecordingStatus;
+export {};

package/dist/extensions/replay/rrweb-plugins/patch.d.ts

@@ -0,0 +1,3 @@
+export declare function patch(source: {
+    [key: string]: any;
+}, name: string, replacement: (...args: unknown[]) => unknown): () => void;

package/dist/extensions/replay/session-recording.d.ts

@@ -0,0 +1,75 @@
+import { Leanbase } from '../../leanbase';
+import { Properties, RemoteConfig, SessionStartReason } from '../../types';
+import { type eventWithTime } from './types/rrweb-types';
+import { SessionRecordingStatus, TriggerType } from './external/triggerMatching';
+export declare class SessionRecording {
+    private readonly _instance;
+    _forceAllowLocalhostNetworkCapture: boolean;
+    private _receivedFlags;
+    private _bootstrapFailed;
+    private _warnedMissingConsent;
+    private _warnedMissingLoader;
+    private _persistFlagsOnSessionListener;
+    private _lazyLoadedSessionRecording;
+    get started(): boolean;
+    /**
+     * 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(): SessionRecordingStatus;
+    constructor(_instance: Leanbase);
+    private get _isRecordingEnabled();
+    startIfEnabledOrStop(startReason?: SessionStartReason): void;
+    /**
+     * 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
+     */
+    private _lazyLoadAndStart;
+    stopRecording(): void;
+    private _resetSampling;
+    private _persistRemoteConfig;
+    private _clearRemoteConfig;
+    onRemoteConfig(response: RemoteConfig): 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
+     * if you are calling this directly you are certainly doing something wrong
+     * @deprecated
+     */
+    onRRwebEmit(rawEvent: eventWithTime): void;
+    /**
+     * 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(): void;
+    /**
+     * 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(): void;
+    /**
+     * 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: TriggerType): void;
+    get sdkDebugProperties(): Properties;
+    /**
+     * 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: string, payload: any): boolean;
+}