@screeb/rrweb 1.0.14 → 1.0.16

package/dist/rrweb.d.ts

@@ -1,48 +1,120 @@
-import { actionWithDelay } from '@rrweb/types';
-import { addedNodeMutation } from '@rrweb/types';
-import { blockClass } from '@rrweb/types';
-import { canvasMutationData } from '@rrweb/types';
-import { DataURLOptions } from '@rrweb/types';
-import { DeprecatedMirror } from '@rrweb/types';
-import { DocumentDimension } from '@rrweb/types';
-import { Emitter } from '@rrweb/types';
-import { EventType } from '@rrweb/types';
-import { eventWithTime } from '@rrweb/types';
-import { Handler } from '@rrweb/types';
-import { hookResetter } from '@rrweb/types';
-import { hooksParam } from '@rrweb/types';
-import { IMirror } from '@rrweb/types';
-import { IncrementalSource } from '@rrweb/types';
-import { IWindow } from '@rrweb/types';
-import { KeepIframeSrcFn } from '@rrweb/types';
-import { listenerHandler } from '@rrweb/types';
-import { MaskInputFn } from 'rrweb-snapshot';
-import { MaskInputOptions } from 'rrweb-snapshot';
-import { maskTextClass } from '@rrweb/types';
-import { MaskTextFn } from 'rrweb-snapshot';
-import { Mirror } from 'rrweb-snapshot';
-import { MouseInteractions } from '@rrweb/types';
-import { PackFn } from '@rrweb/types';
-import { playerMetaData } from '@rrweb/types';
-import { RecordPlugin } from '@rrweb/types';
-import { ReplayerEvents } from '@rrweb/types';
-import { RRDocument } from 'rrdom';
-import { RRIFrameElement } from 'rrdom';
-import { RRNode } from 'rrdom';
-import { SamplingStrategy } from '@rrweb/types';
-import { SlimDOMOptions } from 'rrweb-snapshot';
+import { actionWithDelay } from '@sentry-internal/rrweb-types';
+import { addedNodeMutation } from '@sentry-internal/rrweb-types';
+import { blockClass } from '@sentry-internal/rrweb-types';
+import { CanvasArg } from '@sentry-internal/rrweb-types';
+import { canvasMutationCallback } from '@sentry-internal/rrweb-types';
+import { canvasMutationData } from '@sentry-internal/rrweb-types';
+import { canvasMutationParam } from '@sentry-internal/rrweb-types';
+import { DataURLOptions } from '@sentry-internal/rrweb-snapshot';
+import { DeprecatedMirror } from '@sentry-internal/rrweb-types';
+import { DocumentDimension } from '@sentry-internal/rrweb-types';
+import { Emitter } from '@sentry-internal/rrweb-types';
+import { EventType } from '@sentry-internal/rrweb-types';
+import { eventWithTime } from '@sentry-internal/rrweb-types';
+import { fullSnapshotEvent } from '@sentry-internal/rrweb-types';
+import { Handler } from '@sentry-internal/rrweb-types';
+import { hookResetter } from '@sentry-internal/rrweb-types';
+import { hooksParam } from '@sentry-internal/rrweb-types';
+import { IMirror } from '@sentry-internal/rrweb-snapshot';
+import { incrementalSnapshotEvent } from '@sentry-internal/rrweb-types';
+import { IncrementalSource } from '@sentry-internal/rrweb-types';
+import { inputData } from '@sentry-internal/rrweb-types';
+import { IWindow } from '@sentry-internal/rrweb-types';
+import { KeepIframeSrcFn } from '@sentry-internal/rrweb-types';
+import { listenerHandler } from '@sentry-internal/rrweb-types';
+import { MaskAttributeFn } from '@sentry-internal/rrweb-snapshot';
+import { MaskInputFn } from '@sentry-internal/rrweb-snapshot';
+import { MaskInputOptions } from '@sentry-internal/rrweb-snapshot';
+import { maskTextClass } from '@sentry-internal/rrweb-types';
+import { MaskTextFn } from '@sentry-internal/rrweb-snapshot';
+import { Mirror } from '@sentry-internal/rrweb-snapshot';
+import { MouseInteractions } from '@sentry-internal/rrweb-types';
+import { PackFn } from '@sentry-internal/rrweb-types';
+import { playerMetaData } from '@sentry-internal/rrweb-types';
+import { RecordPlugin } from '@sentry-internal/rrweb-types';
+import { ReplayerEvents } from '@sentry-internal/rrweb-types';
+import { RRDocument } from '@sentry-internal/rrdom';
+import { RRIFrameElement } from '@sentry-internal/rrdom';
+import { RRNode } from '@sentry-internal/rrdom';
+import { SamplingStrategy } from '@sentry-internal/rrweb-types';
+import { SlimDOMOptions } from '@sentry-internal/rrweb-snapshot';
 import { StateMachine } from '@xstate/fsm';
-import { textMutation } from '@rrweb/types';
-import { throttleOptions } from '@rrweb/types';
-import { UnpackFn } from '@rrweb/types';
+import { textMutation } from '@sentry-internal/rrweb-types';
+import { throttleOptions } from '@sentry-internal/rrweb-types';
+import { unmaskTextClass } from '@sentry-internal/rrweb-types';
+import { UnpackFn } from '@sentry-internal/rrweb-types';
 
-export declare const addCustomEvent: <T>(tag: string, payload: T) => void;
+export declare function addCustomEvent<T>(tag: string, payload: T): void;
 
 declare type AppendedIframe = {
     mutationInQueue: addedNodeMutation;
     builtNode: HTMLIFrameElement | RRIFrameElement;
 };
 
+export declare class CanvasManager implements CanvasManagerInterface {
+    private pendingCanvasMutations;
+    private rafStamps;
+    private options;
+    private mirror;
+    private shadowDoms;
+    private windowsSet;
+    private windows;
+    private mutationCb;
+    private restoreHandlers;
+    private frozen;
+    private locked;
+    private snapshotInProgressMap;
+    private worker;
+    private lastSnapshotTime;
+    reset(): void;
+    freeze(): void;
+    unfreeze(): void;
+    lock(): void;
+    unlock(): void;
+    constructor(options: CanvasManagerConstructorOptions);
+    addWindow(win: IWindow): void;
+    addShadowRoot(shadowRoot: ShadowRoot): void;
+    resetShadowRoots(): void;
+    snapshot(canvasElement?: HTMLCanvasElement, options?: SnapshotOptions): void;
+    private initFPSWorker;
+    private processMutation;
+    private initCanvasFPSObserver;
+    private initCanvasMutationObserver;
+    private getCanvasElements;
+    private takeSnapshot;
+    private startPendingCanvasMutationFlusher;
+    private startRAFTimestamping;
+    flushPendingCanvasMutations(): void;
+    flushPendingCanvasMutationFor(canvas: HTMLCanvasElement, id: number): void;
+}
+
+export declare interface CanvasManagerConstructorOptions {
+    recordCanvas: boolean;
+    enableManualSnapshot?: boolean;
+    mutationCb: canvasMutationCallback;
+    win: IWindow;
+    blockClass: blockClass;
+    blockSelector: string | null;
+    unblockSelector: string | null;
+    maxCanvasSize?: MaxCanvasSize | null;
+    mirror: Mirror;
+    dataURLOptions: DataURLOptions;
+    errorHandler?: ErrorHandler;
+    sampling?: 'all' | number;
+}
+
+declare interface CanvasManagerInterface {
+    reset(): void;
+    freeze(): void;
+    unfreeze(): void;
+    lock(): void;
+    unlock(): void;
+    snapshot(canvasElement?: HTMLCanvasElement, options?: SnapshotOptions): void;
+    addWindow(win: IWindow): void;
+    addShadowRoot(shadowRoot: ShadowRoot): void;
+    resetShadowRoots(): void;
+}
+
 export declare function canvasMutation({ event, mutation, target, imageMap, canvasEventMap, errorHandler, }: {
     event: Parameters<Replayer['applyIncremental']>[0];
     mutation: canvasMutationData;
@@ -52,19 +124,31 @@ export declare function canvasMutation({ event, mutation, target, imageMap, canv
     errorHandler: Replayer['warnCanvasMutationFailed'];
 }): Promise<void>;
 
+export { canvasMutationData }
+
+export { canvasMutationParam }
+
+declare function clearTimeout_2(...rest: Parameters<typeof window.clearTimeout>): ReturnType<typeof window.clearTimeout>;
+
 declare function closestElementOfNode(node: Node | null): HTMLElement | null;
 
 declare function createPlayerService(context: PlayerContext, { getCastFn, applyEventsSynchronously, emitter }: PlayerAssets): StateMachine.Service<PlayerContext, PlayerEvent, PlayerState>;
 
 declare function createSpeedService(context: SpeedContext): StateMachine.Service<SpeedContext, SpeedEvent, SpeedState>;
 
+export declare function deserializeArg(imageMap: Replayer['imageMap'], ctx: CanvasRenderingContext2D | WebGLRenderingContext | WebGL2RenderingContext | null, preload?: {
+    isUnchanged: boolean;
+}): (arg: CanvasArg) => Promise<any>;
+
 declare type ErrorHandler = (error: unknown) => void | boolean;
 
 export { EventType }
 
 export { eventWithTime }
 
-export declare const freezePage: () => void;
+export declare function freezePage(): void;
+
+export { fullSnapshotEvent }
 
 declare function getBaseDimension(node: Node, rootIframe: Node): DocumentDimension;
 
@@ -94,15 +178,19 @@ declare function hasShadowRoot<T extends Node | RRNode>(n: T): n is T & {
 
 declare function hookSetter<T>(target: T, key: string | number | symbol, d: PropertyDescriptor, isRevoked?: boolean, win?: Window & typeof globalThis): hookResetter;
 
+export { incrementalSnapshotEvent }
+
 export { IncrementalSource }
 
 declare function inDom(n: Node): boolean;
 
+export { inputData }
+
 declare function isAncestorRemoved(target: Node, mirror: Mirror): boolean;
 
-declare function isBlocked(node: Node | null, blockClass: blockClass, blockSelector: string | null, checkAncestors: boolean): boolean;
+declare function isBlocked(node: Node | null, blockClass: blockClass, blockSelector: string | null, unblockSelector: string | null, checkAncestors: boolean): boolean;
 
-declare function isIgnored(n: Node, mirror: Mirror, slimDOMOptions: SlimDOMOptions): boolean;
+declare function isIgnored(n: Node, mirror: Mirror): boolean;
 
 declare function isSerialized(n: Node, mirror: Mirror): boolean;
 
@@ -114,7 +202,9 @@ declare function iterateResolveTree(tree: ResolveTree, cb: (mutation: addedNodeM
 
 declare function legacy_isTouchEvent(event: MouseEvent | TouchEvent | PointerEvent): event is TouchEvent;
 
-export declare let mirror: DeprecatedMirror;
+declare type MaxCanvasSize = [number, number];
+
+declare let _mirror: DeprecatedMirror;
 
 export { MouseInteractions }
 
@@ -122,6 +212,12 @@ declare let nowTimestamp: () => number;
 
 declare function on(type: string, fn: EventListenerOrEventListenerObject, target?: Document | IWindow): listenerHandler;
 
+declare function onRequestAnimationFrame(...rest: Parameters<typeof requestAnimationFrame>): ReturnType<typeof requestAnimationFrame>;
+
+declare function patch(source: {
+    [key: string]: any;
+}, name: string, replacement: (...args: unknown[]) => unknown): () => void;
+
 declare type PlayerAssets = {
     emitter: Emitter;
     applyEventsSynchronously(events: Array<eventWithTime>): void;
@@ -194,7 +290,7 @@ declare type PlayerEvent = {
 
 export declare type PlayerMachineState = StateMachine.State<PlayerContext, PlayerEvent, PlayerState>;
 
-declare type PlayerState = {
+export declare type PlayerState = {
     value: 'playing';
     context: PlayerContext;
 } | {
@@ -212,10 +308,8 @@ declare function queueToResolveTrees(queue: addedNodeMutation[]): ResolveTree[];
 export declare function record<T = eventWithTime>(options?: recordOptions<T>): listenerHandler | undefined;
 
 export declare namespace record {
-    var addCustomEvent: <T>(tag: string, payload: T) => void;
-    var freezePage: () => void;
-    var takeFullSnapshot: (isCheckout?: boolean | undefined) => void;
     var mirror: Mirror;
+    var takeFullSnapshot: takeFullSnapshot;
 }
 
 export declare type recordOptions<T> = {
@@ -224,14 +318,20 @@ export declare type recordOptions<T> = {
     checkoutEveryNms?: number;
     blockClass?: blockClass;
     blockSelector?: string;
+    unblockSelector?: string;
     ignoreClass?: string;
     ignoreSelector?: string;
+    maskAllText?: boolean;
     maskTextClass?: maskTextClass;
+    unmaskTextClass?: unmaskTextClass;
     maskTextSelector?: string;
+    unmaskTextSelector?: string;
     maskAllInputs?: boolean;
     maskInputOptions?: MaskInputOptions;
+    maskAttributeFn?: MaskAttributeFn;
     maskInputFn?: MaskInputFn;
     maskTextFn?: MaskTextFn;
+    maxCanvasSize?: [number, number];
     slimDOMOptions?: SlimDOMOptions | 'all' | true;
     ignoreCSSAttributes?: Set<string>;
     inlineStylesheet?: boolean;
@@ -251,6 +351,8 @@ export declare type recordOptions<T> = {
     mousemoveWait?: number;
     keepIframeSrcFn?: KeepIframeSrcFn;
     errorHandler?: ErrorHandler;
+    onMutation?: (mutations: MutationRecord[]) => boolean;
+    getCanvasManager?: (options: CanvasManagerConstructorOptions) => CanvasManagerInterface;
 };
 
 export declare class Replayer {
@@ -262,9 +364,6 @@ export declare class Replayer {
     config: playerConfig;
     usingVirtualDom: boolean;
     virtualDom: RRDocument;
-    private mouse;
-    private mouseTail;
-    private tailPositions;
     private emitter;
     private nextUserInteractionEvent;
     private legacy_missingNodeRetryMap;
@@ -273,17 +372,16 @@ export declare class Replayer {
     private canvasEventMap;
     private mirror;
     private styleMirror;
-    private mediaManager;
     private firstFullSnapshot;
     private newDocumentQueue;
-    private mousePos;
-    private touchActive;
+    private pointers;
     private lastMouseDownEvent;
     private lastHoveredRootNode;
     private lastSelectionData;
     private constructedStyleMutations;
     private adoptedStyleSheets;
     constructor(events: Array<eventWithTime | string>, config?: Partial<playerConfig>);
+    private createPointer;
     on(event: string, handler: Handler): this;
     off(event: string, handler: Handler): this;
     setConfig(config: Partial<playerConfig>): void;
@@ -300,6 +398,7 @@ export declare class Replayer {
     enableInteract(): void;
     disableInteract(): void;
     resetCache(): void;
+    private reevaluateFastForward;
     private setupDom;
     private handleResize;
     private applyEventsSynchronously;
@@ -355,8 +454,14 @@ declare type ResolveTree = {
     parent: ResolveTree | null;
 };
 
+declare function setTimeout_2(...rest: Parameters<typeof window.setTimeout>): ReturnType<typeof window.setTimeout>;
+
 declare function shadowHostInDom(n: Node): boolean;
 
+declare type SnapshotOptions = {
+    skipRequestAnimationFrame?: boolean;
+};
+
 declare type SpeedContext = {
     normalSpeed: playerConfig['speed'];
     timer: Timer;
@@ -378,7 +483,7 @@ declare type SpeedEvent = {
 
 export declare type SpeedMachineState = StateMachine.State<SpeedContext, SpeedEvent, SpeedState>;
 
-declare type SpeedState = {
+export declare type SpeedState = {
     value: 'normal';
     context: SpeedContext;
 } | {
@@ -398,7 +503,7 @@ declare class StyleSheetMirror {
     generateId(): number;
 }
 
-export declare const takeFullSnapshot: (isCheckout?: boolean | undefined) => void;
+export declare function takeFullSnapshot(isCheckout?: boolean): void;
 
 declare function throttle<T>(func: (arg: T) => void, wait: number, options?: throttleOptions): (...args: T[]) => void;
 
@@ -427,6 +532,7 @@ declare namespace utils {
         on,
         throttle,
         hookSetter,
+        patch,
         getWindowScroll,
         getWindowHeight,
         getWindowWidth,
@@ -450,7 +556,10 @@ declare namespace utils {
         getRootShadowHost,
         shadowHostInDom,
         inDom,
-        mirror as _mirror,
+        onRequestAnimationFrame,
+        setTimeout_2 as setTimeout,
+        clearTimeout_2 as clearTimeout,
+        _mirror,
         nowTimestamp,
         AppendedIframe,
         StyleSheetMirror
@@ -461,11 +570,15 @@ export { utils }
 export { }
 
 
+declare global {
+    const __RRWEB_EXCLUDE_SHADOW_DOM__: boolean;
+    const __RRWEB_EXCLUDE_IFRAME__: boolean;
+}
+
+
 declare namespace record {
-    var addCustomEvent: <T>(tag: string, payload: T) => void;
-    var freezePage: () => void;
-    var takeFullSnapshot: (isCheckout?: boolean | undefined) => void;
-    var mirror: import("rrweb-snapshot").Mirror;
+    var mirror: import("@sentry-internal/rrweb-snapshot").Mirror;
+    var takeFullSnapshot: typeof import(".").takeFullSnapshot;
 }