posthog-js 1.63.1 → 1.63.3

package/dist/module.d.ts

@@ -1,6 +1,66 @@
-import { record } from 'rrweb2/typings';
-import { listenerHandler, eventWithTime } from '@rrweb/types';
-
+declare enum NodeType {
+    Document = 0,
+    DocumentType = 1,
+    Element = 2,
+    Text = 3,
+    CDATA = 4,
+    Comment = 5
+}
+declare type documentNode = {
+    type: NodeType.Document;
+    childNodes: serializedNodeWithId[];
+    compatMode?: string;
+};
+declare type documentTypeNode = {
+    type: NodeType.DocumentType;
+    name: string;
+    publicId: string;
+    systemId: string;
+};
+declare type attributes = {
+    [key: string]: string | number | true | null;
+};
+declare type elementNode = {
+    type: NodeType.Element;
+    tagName: string;
+    attributes: attributes;
+    childNodes: serializedNodeWithId[];
+    isSVG?: true;
+    needBlock?: boolean;
+};
+declare type textNode = {
+    type: NodeType.Text;
+    textContent: string;
+    isStyle?: true;
+};
+declare type cdataNode = {
+    type: NodeType.CDATA;
+    textContent: '';
+};
+declare type commentNode = {
+    type: NodeType.Comment;
+    textContent: string;
+};
+declare type serializedNode = (documentNode | documentTypeNode | elementNode | textNode | cdataNode | commentNode) & {
+    rootId?: number;
+    isShadowHost?: boolean;
+    isShadow?: boolean;
+};
+declare type serializedNodeWithId = serializedNode & {
+    id: number;
+};
+interface IMirror<TNode> {
+    getId(n: TNode | undefined | null): number;
+    getNode(id: number): TNode | null;
+    getIds(): number[];
+    getMeta(n: TNode): serializedNodeWithId | null;
+    removeNodeFromMap(n: TNode): void;
+    has(id: number): boolean;
+    hasNode(node: TNode): boolean;
+    add(n: TNode, meta: serializedNodeWithId): void;
+    replace(id: number, n: TNode): void;
+    reset(): void;
+}
 declare type MaskInputOptions = Partial<{
     color: boolean;
     date: boolean;
@@ -31,6 +91,27 @@ declare type SlimDOMOptions = Partial<{
     headMetaAuthorship: boolean;
     headMetaVerification: boolean;
 }>;
+declare type DataURLOptions = Partial<{
+    type: string;
+    quality: number;
+}>;
+declare type MaskTextFn = (text: string) => string;
+declare type MaskInputFn = (text: string, element: HTMLElement) => string;
+
+declare class Mirror implements IMirror<Node> {
+    private idNodeMap;
+    private nodeMetaMap;
+    getId(n: Node | undefined | null): number;
+    getNode(id: number): Node | null;
+    getIds(): number[];
+    getMeta(n: Node): serializedNodeWithId | null;
+    removeNodeFromMap(n: Node): void;
+    has(id: number): boolean;
+    hasNode(node: Node): boolean;
+    add(n: Node, meta: serializedNodeWithId): void;
+    replace(id: number, n: Node): void;
+    reset(): void;
+}
 
 declare class CaptureMetrics {
     enabled: boolean;
@@ -112,7 +193,6 @@ interface PostHogConfig {
     ui_host: string | null;
     token: string;
     autocapture: boolean | AutocaptureConfig;
-    autocapture_exceptions: boolean;
     rageclick: boolean;
     cross_subdomain_cookie: boolean;
     persistence: 'localStorage' | 'cookie' | 'memory' | 'localStorage+cookie' | 'sessionStorage';
@@ -491,6 +571,385 @@ declare class PostHogFeatureFlags {
     resetGroupPropertiesForFlags(group_type?: string): void;
 }
 
+declare enum EventType {
+    DomContentLoaded = 0,
+    Load = 1,
+    FullSnapshot = 2,
+    IncrementalSnapshot = 3,
+    Meta = 4,
+    Custom = 5,
+    Plugin = 6
+}
+declare type domContentLoadedEvent = {
+    type: EventType.DomContentLoaded;
+    data: unknown;
+};
+declare type loadedEvent = {
+    type: EventType.Load;
+    data: unknown;
+};
+declare type fullSnapshotEvent = {
+    type: EventType.FullSnapshot;
+    data: {
+        node: serializedNodeWithId;
+        initialOffset: {
+            top: number;
+            left: number;
+        };
+    };
+};
+declare type incrementalSnapshotEvent = {
+    type: EventType.IncrementalSnapshot;
+    data: incrementalData;
+};
+declare type metaEvent = {
+    type: EventType.Meta;
+    data: {
+        href: string;
+        width: number;
+        height: number;
+    };
+};
+declare type customEvent<T = unknown> = {
+    type: EventType.Custom;
+    data: {
+        tag: string;
+        payload: T;
+    };
+};
+declare type pluginEvent<T = unknown> = {
+    type: EventType.Plugin;
+    data: {
+        plugin: string;
+        payload: T;
+    };
+};
+declare enum IncrementalSource {
+    Mutation = 0,
+    MouseMove = 1,
+    MouseInteraction = 2,
+    Scroll = 3,
+    ViewportResize = 4,
+    Input = 5,
+    TouchMove = 6,
+    MediaInteraction = 7,
+    StyleSheetRule = 8,
+    CanvasMutation = 9,
+    Font = 10,
+    Log = 11,
+    Drag = 12,
+    StyleDeclaration = 13,
+    Selection = 14,
+    AdoptedStyleSheet = 15
+}
+declare type mutationData = {
+    source: IncrementalSource.Mutation;
+} & mutationCallbackParam;
+declare type mousemoveData = {
+    source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag;
+    positions: mousePosition[];
+};
+declare type mouseInteractionData = {
+    source: IncrementalSource.MouseInteraction;
+} & mouseInteractionParam;
+declare type scrollData = {
+    source: IncrementalSource.Scroll;
+} & scrollPosition;
+declare type viewportResizeData = {
+    source: IncrementalSource.ViewportResize;
+} & viewportResizeDimension;
+declare type inputData = {
+    source: IncrementalSource.Input;
+    id: number;
+} & inputValue;
+declare type mediaInteractionData = {
+    source: IncrementalSource.MediaInteraction;
+} & mediaInteractionParam;
+declare type styleSheetRuleData = {
+    source: IncrementalSource.StyleSheetRule;
+} & styleSheetRuleParam;
+declare type styleDeclarationData = {
+    source: IncrementalSource.StyleDeclaration;
+} & styleDeclarationParam;
+declare type canvasMutationData = {
+    source: IncrementalSource.CanvasMutation;
+} & canvasMutationParam;
+declare type fontData = {
+    source: IncrementalSource.Font;
+} & fontParam;
+declare type selectionData = {
+    source: IncrementalSource.Selection;
+} & selectionParam;
+declare type adoptedStyleSheetData = {
+    source: IncrementalSource.AdoptedStyleSheet;
+} & adoptedStyleSheetParam;
+declare type incrementalData = mutationData | mousemoveData | mouseInteractionData | scrollData | viewportResizeData | inputData | mediaInteractionData | styleSheetRuleData | canvasMutationData | fontData | selectionData | styleDeclarationData | adoptedStyleSheetData;
+declare type event = domContentLoadedEvent | loadedEvent | fullSnapshotEvent | incrementalSnapshotEvent | metaEvent | customEvent | pluginEvent;
+declare type eventWithTime = event & {
+    timestamp: number;
+    delay?: number;
+};
+declare type blockClass = string | RegExp;
+declare type maskTextClass = string | RegExp;
+declare type SamplingStrategy = Partial<{
+    mousemove: boolean | number;
+    mousemoveCallback: number;
+    mouseInteraction: boolean | Record<string, boolean | undefined>;
+    scroll: number;
+    media: number;
+    input: 'all' | 'last';
+    canvas: 'all' | number;
+}>;
+interface ICrossOriginIframeMirror {
+    getId(iframe: HTMLIFrameElement, remoteId: number, parentToRemoteMap?: Map<number, number>, remoteToParentMap?: Map<number, number>): number;
+    getIds(iframe: HTMLIFrameElement, remoteId: number[]): number[];
+    getRemoteId(iframe: HTMLIFrameElement, parentId: number, map?: Map<number, number>): number;
+    getRemoteIds(iframe: HTMLIFrameElement, parentId: number[]): number[];
+    reset(iframe?: HTMLIFrameElement): void;
+}
+declare type RecordPlugin<TOptions = unknown> = {
+    name: string;
+    observer?: (cb: (...args: Array<unknown>) => void, win: IWindow, options: TOptions) => listenerHandler;
+    eventProcessor?: <TExtend>(event: eventWithTime) => eventWithTime & TExtend;
+    getMirror?: (mirrors: {
+        nodeMirror: Mirror;
+        crossOriginIframeMirror: ICrossOriginIframeMirror;
+        crossOriginIframeStyleMirror: ICrossOriginIframeMirror;
+    }) => void;
+    options: TOptions;
+};
+declare type hooksParam = {
+    mutation?: mutationCallBack;
+    mousemove?: mousemoveCallBack;
+    mouseInteraction?: mouseInteractionCallBack;
+    scroll?: scrollCallback;
+    viewportResize?: viewportResizeCallback;
+    input?: inputCallback;
+    mediaInteaction?: mediaInteractionCallback;
+    styleSheetRule?: styleSheetRuleCallback;
+    styleDeclaration?: styleDeclarationCallback;
+    canvasMutation?: canvasMutationCallback;
+    font?: fontCallback;
+    selection?: selectionCallback;
+};
+declare type textMutation = {
+    id: number;
+    value: string | null;
+};
+declare type styleAttributeValue = {
+    [key: string]: styleValueWithPriority | string | false;
+};
+declare type styleValueWithPriority = [string, string];
+declare type attributeMutation = {
+    id: number;
+    attributes: {
+        [key: string]: string | styleAttributeValue | null;
+    };
+};
+declare type removedNodeMutation = {
+    parentId: number;
+    id: number;
+    isShadow?: boolean;
+};
+declare type addedNodeMutation = {
+    parentId: number;
+    previousId?: number | null;
+    nextId: number | null;
+    node: serializedNodeWithId;
+};
+declare type mutationCallbackParam = {
+    texts: textMutation[];
+    attributes: attributeMutation[];
+    removes: removedNodeMutation[];
+    adds: addedNodeMutation[];
+    isAttachIframe?: true;
+};
+declare type mutationCallBack = (m: mutationCallbackParam) => void;
+declare type mousemoveCallBack = (p: mousePosition[], source: IncrementalSource.MouseMove | IncrementalSource.TouchMove | IncrementalSource.Drag) => void;
+declare type mousePosition = {
+    x: number;
+    y: number;
+    id: number;
+    timeOffset: number;
+};
+declare enum MouseInteractions {
+    MouseUp = 0,
+    MouseDown = 1,
+    Click = 2,
+    ContextMenu = 3,
+    DblClick = 4,
+    Focus = 5,
+    Blur = 6,
+    TouchStart = 7,
+    TouchMove_Departed = 8,
+    TouchEnd = 9,
+    TouchCancel = 10
+}
+declare enum PointerTypes {
+    Mouse = 0,
+    Pen = 1,
+    Touch = 2
+}
+declare enum CanvasContext {
+    '2D' = 0,
+    WebGL = 1,
+    WebGL2 = 2
+}
+declare type mouseInteractionParam = {
+    type: MouseInteractions;
+    id: number;
+    x: number;
+    y: number;
+    pointerType?: PointerTypes;
+};
+declare type mouseInteractionCallBack = (d: mouseInteractionParam) => void;
+declare type scrollPosition = {
+    id: number;
+    x: number;
+    y: number;
+};
+declare type scrollCallback = (p: scrollPosition) => void;
+declare type styleSheetAddRule = {
+    rule: string;
+    index?: number | number[];
+};
+declare type styleSheetDeleteRule = {
+    index: number | number[];
+};
+declare type styleSheetRuleParam = {
+    id?: number;
+    styleId?: number;
+    removes?: styleSheetDeleteRule[];
+    adds?: styleSheetAddRule[];
+    replace?: string;
+    replaceSync?: string;
+};
+declare type styleSheetRuleCallback = (s: styleSheetRuleParam) => void;
+declare type adoptedStyleSheetParam = {
+    id: number;
+    styles?: {
+        styleId: number;
+        rules: styleSheetAddRule[];
+    }[];
+    styleIds: number[];
+};
+declare type styleDeclarationParam = {
+    id?: number;
+    styleId?: number;
+    index: number[];
+    set?: {
+        property: string;
+        value: string | null;
+        priority: string | undefined;
+    };
+    remove?: {
+        property: string;
+    };
+};
+declare type styleDeclarationCallback = (s: styleDeclarationParam) => void;
+declare type canvasMutationCommand = {
+    property: string;
+    args: Array<unknown>;
+    setter?: true;
+};
+declare type canvasMutationParam = {
+    id: number;
+    type: CanvasContext;
+    commands: canvasMutationCommand[];
+} | ({
+    id: number;
+    type: CanvasContext;
+} & canvasMutationCommand);
+declare type canvasMutationCallback = (p: canvasMutationParam) => void;
+declare type fontParam = {
+    family: string;
+    fontSource: string;
+    buffer: boolean;
+    descriptors?: FontFaceDescriptors;
+};
+declare type fontCallback = (p: fontParam) => void;
+declare type viewportResizeDimension = {
+    width: number;
+    height: number;
+};
+declare type viewportResizeCallback = (d: viewportResizeDimension) => void;
+declare type inputValue = {
+    text: string;
+    isChecked: boolean;
+    userTriggered?: boolean;
+};
+declare type inputCallback = (v: inputValue & {
+    id: number;
+}) => void;
+declare const enum MediaInteractions {
+    Play = 0,
+    Pause = 1,
+    Seeked = 2,
+    VolumeChange = 3,
+    RateChange = 4
+}
+declare type mediaInteractionParam = {
+    type: MediaInteractions;
+    id: number;
+    currentTime?: number;
+    volume?: number;
+    muted?: boolean;
+    playbackRate?: number;
+};
+declare type mediaInteractionCallback = (p: mediaInteractionParam) => void;
+declare type SelectionRange = {
+    start: number;
+    startOffset: number;
+    end: number;
+    endOffset: number;
+};
+declare type selectionParam = {
+    ranges: Array<SelectionRange>;
+};
+declare type selectionCallback = (p: selectionParam) => void;
+declare type listenerHandler = () => void;
+declare type KeepIframeSrcFn = (src: string) => boolean;
+declare global {
+    interface Window {
+        FontFace: typeof FontFace;
+    }
+}
+declare type IWindow = Window & typeof globalThis;
+
+declare type rrwebRecord = {
+    (options: recordOptions<eventWithTime>): listenerHandler;
+    addCustomEvent: (tag: string, payload: any) => void;
+    takeFullSnapshot: () => void;
+};
+declare type recordOptions<T> = {
+    emit?: (e: T, isCheckout?: boolean) => void;
+    checkoutEveryNth?: number;
+    checkoutEveryNms?: number;
+    blockClass?: blockClass;
+    blockSelector?: string;
+    ignoreClass?: string;
+    maskTextClass?: maskTextClass;
+    maskTextSelector?: string;
+    maskAllInputs?: boolean;
+    maskInputOptions?: MaskInputOptions;
+    maskInputFn?: MaskInputFn;
+    maskTextFn?: MaskTextFn;
+    slimDOMOptions?: SlimDOMOptions | 'all' | true;
+    ignoreCSSAttributes?: Set<string>;
+    inlineStylesheet?: boolean;
+    hooks?: hooksParam;
+    sampling?: SamplingStrategy;
+    dataURLOptions?: DataURLOptions;
+    recordCanvas?: boolean;
+    recordCrossOriginIframes?: boolean;
+    recordAfter?: 'DOMContentLoaded' | 'load';
+    userTriggeredOnInput?: boolean;
+    collectFonts?: boolean;
+    inlineImages?: boolean;
+    plugins?: RecordPlugin[];
+    mousemoveWait?: number;
+    keepIframeSrcFn?: KeepIframeSrcFn;
+};
 declare class SessionRecording {
     instance: PostHog;
     captureStarted: boolean;
@@ -501,7 +960,7 @@ declare class SessionRecording {
     windowId: string | null;
     sessionId: string | null;
     receivedDecide: boolean;
-    rrwebRecord: typeof record | undefined;
+    rrwebRecord: rrwebRecord | undefined;
     recorderVersion?: string;
     lastActivityTimestamp: number;
     isIdle: boolean;
@@ -644,19 +1103,18 @@ declare class ExceptionObserver {
     private originalOnErrorHandler;
     private originalOnUnhandledRejectionHandler;
     constructor(instance: PostHog);
-    startObservingIfEnabled(): void;
     startCapturing(): void;
     stopCapturing(): void;
     isCapturing(): boolean;
     isEnabled(): boolean;
     afterDecideResponse(response: DecideResponse): void;
+    captureException(args: ErrorEventArgs, properties?: Properties): void;
     /**
      * :TRICKY: Make sure we batch these requests
      */
     sendExceptionEvent(properties: {
         [key: string]: any;
     }): void;
-    captureException(args: ErrorEventArgs, properties?: Properties): void;
 }
 
 /**