@highlight-run/rrweb 1.2.1 → 2.0.0-lambda.1

package/dist/record/observers/canvas/canvas-manager.d.ts

@@ -1,32 +0,0 @@
-import { blockClass, canvasMutationCallback, IWindow, Mirror } from '../../../types';
-export declare type RafStamps = {
-    latestId: number;
-    invokeId: number | null;
-};
-export declare class CanvasManager {
-    private pendingCanvasMutations;
-    private rafStamps;
-    private mirror;
-    private mutationCb;
-    private resetObservers?;
-    private frozen;
-    private locked;
-    reset(): void;
-    freeze(): void;
-    unfreeze(): void;
-    lock(): void;
-    unlock(): void;
-    constructor(options: {
-        recordCanvas: boolean | number;
-        mutationCb: canvasMutationCallback;
-        win: IWindow;
-        blockClass: blockClass;
-        mirror: Mirror;
-    });
-    private processMutation;
-    private initCanvasMutationObserver;
-    private startPendingCanvasMutationFlusher;
-    private startRAFTimestamping;
-    flushPendingCanvasMutations(): void;
-    flushPendingCanvasMutationFor(canvas: HTMLCanvasElement, id: number): void;
-}

package/dist/record/observers/canvas/canvas.d.ts

@@ -1,2 +0,0 @@
-import { blockClass, IWindow, listenerHandler } from '../../../types';
-export default function initCanvasContextObserver(win: IWindow, blockClass: blockClass): listenerHandler;

package/dist/record/observers/canvas/serialize-args.d.ts

@@ -1,6 +0,0 @@
-import { IWindow, SerializedWebGlArg } from '../../../types';
-export declare function variableListFor(ctx: WebGLRenderingContext | WebGL2RenderingContext, ctor: string): any[];
-export declare const saveWebGLVar: (value: any, win: IWindow, ctx: WebGL2RenderingContext | WebGLRenderingContext) => number | void;
-export declare function serializeArg(value: any, win: IWindow, ctx: WebGL2RenderingContext | WebGLRenderingContext): SerializedWebGlArg;
-export declare const serializeArgs: (args: Array<any>, win: IWindow, ctx: WebGLRenderingContext | WebGL2RenderingContext) => SerializedWebGlArg[];
-export declare const isInstanceOfWebGLObject: (value: any, win: IWindow) => value is WebGLShader | WebGLProgram | WebGLActiveInfo | WebGLBuffer | WebGLFramebuffer | WebGLRenderbuffer | WebGLShaderPrecisionFormat | WebGLTexture | WebGLUniformLocation | WebGLVertexArrayObject;

package/dist/record/observers/canvas/webgl.d.ts

@@ -1,2 +0,0 @@
-import { blockClass, canvasManagerMutationCallback, IWindow, listenerHandler, Mirror } from '../../../types';
-export default function initCanvasWebGLMutationObserver(cb: canvasManagerMutationCallback, win: IWindow, blockClass: blockClass, mirror: Mirror): listenerHandler;

package/dist/record/shadow-dom-manager.d.ts

@@ -1,34 +0,0 @@
-import { mutationCallBack, blockClass, maskTextClass, Mirror, scrollCallback, SamplingStrategy } from '../types';
-import { MaskInputOptions, SlimDOMOptions, MaskTextFn, MaskInputFn } from '../snapshot';
-import { IframeManager } from './iframe-manager';
-import { CanvasManager } from './observers/canvas/canvas-manager';
-declare type BypassOptions = {
-    blockClass: blockClass;
-    blockSelector: string | null;
-    maskTextClass: maskTextClass;
-    maskTextSelector: string | null;
-    inlineStylesheet: boolean;
-    maskInputOptions: MaskInputOptions;
-    maskTextFn: MaskTextFn | undefined;
-    maskInputFn: MaskInputFn | undefined;
-    recordCanvas: boolean;
-    sampling: SamplingStrategy;
-    slimDOMOptions: SlimDOMOptions;
-    iframeManager: IframeManager;
-    canvasManager: CanvasManager;
-    enableStrictPrivacy: boolean;
-};
-export declare class ShadowDomManager {
-    private mutationCb;
-    private scrollCb;
-    private bypassOptions;
-    private mirror;
-    constructor(options: {
-        mutationCb: mutationCallBack;
-        scrollCb: scrollCallback;
-        bypassOptions: BypassOptions;
-        mirror: Mirror;
-    });
-    addShadowRoot(shadowRoot: ShadowRoot, doc: Document): void;
-}
-export {};

package/dist/replay/canvas/2d.d.ts

@@ -1,9 +0,0 @@
-import { Replayer } from '../';
-import { canvasMutationCommand } from '../../types';
-export default function canvasMutation({ event, mutation, target, imageMap, errorHandler, }: {
-    event: Parameters<Replayer['applyIncremental']>[0];
-    mutation: canvasMutationCommand;
-    target: HTMLCanvasElement;
-    imageMap: Replayer['imageMap'];
-    errorHandler: Replayer['warnCanvasMutationFailed'];
-}): void;

package/dist/replay/canvas/index.d.ts

@@ -1,9 +0,0 @@
-import { Replayer } from '..';
-import { canvasMutationData } from '../../types';
-export default function canvasMutation({ event, mutation, target, imageMap, errorHandler, }: {
-    event: Parameters<Replayer['applyIncremental']>[0];
-    mutation: canvasMutationData;
-    target: HTMLCanvasElement;
-    imageMap: Replayer['imageMap'];
-    errorHandler: Replayer['warnCanvasMutationFailed'];
-}): void;

package/dist/replay/canvas/webgl.d.ts

@@ -1,11 +0,0 @@
-import { Replayer } from '../';
-import { CanvasContext, canvasMutationCommand, SerializedWebGlArg } from '../../types';
-export declare function variableListFor(ctx: WebGLRenderingContext | WebGL2RenderingContext, ctor: string): any[];
-export declare function deserializeArg(imageMap: Replayer['imageMap'], ctx: WebGLRenderingContext | WebGL2RenderingContext): (arg: SerializedWebGlArg) => any;
-export default function webglMutation({ mutation, target, type, imageMap, errorHandler, }: {
-    mutation: canvasMutationCommand;
-    target: HTMLCanvasElement;
-    type: CanvasContext;
-    imageMap: Replayer['imageMap'];
-    errorHandler: Replayer['warnCanvasMutationFailed'];
-}): void;

package/dist/replay/index.d.ts

@@ -1,82 +0,0 @@
-import { Timer } from './timer';
-import { createPlayerService, createSpeedService } from './machine';
-import { eventWithTime, playerConfig, playerMetaData, Handler, Mirror, SessionInterval } from '../types';
-import './styles/style.css';
-export declare class Replayer {
-    wrapper: HTMLDivElement;
-    iframe: HTMLIFrameElement;
-    service: ReturnType<typeof createPlayerService>;
-    speedService: ReturnType<typeof createSpeedService>;
-    get timer(): Timer;
-    config: playerConfig;
-    private mouse;
-    private mouseTail;
-    private tailPositions;
-    private emitter;
-    private nextUserInteractionEvent;
-    private activityIntervals;
-    private inactiveEndTimestamp;
-    private legacy_missingNodeRetryMap;
-    private treeIndex;
-    private fragmentParentMap;
-    private elementStateMap;
-    private virtualStyleRulesMap;
-    private cache;
-    private imageMap;
-    private mirror;
-    private firstFullSnapshot;
-    private newDocumentQueue;
-    private mousePos;
-    private touchActive;
-    constructor(events: Array<eventWithTime | string>, config?: Partial<playerConfig>);
-    on(event: string, handler: Handler): this;
-    off(event: string, handler: Handler): this;
-    setConfig(config: Partial<playerConfig>): void;
-    getActivityIntervals(): Array<SessionInterval>;
-    getMetaData(): playerMetaData;
-    getCurrentTime(): number;
-    getTimeOffset(): number;
-    getMirror(): Mirror;
-    play(timeOffset?: number): void;
-    pause(timeOffset?: number): void;
-    resume(timeOffset?: number): void;
-    startLive(baselineTime?: number): void;
-    addEvent(rawEvent: eventWithTime | string): void;
-    replaceEvents(events: eventWithTime[]): void;
-    enableInteract(): void;
-    disableInteract(): void;
-    resetCache(): void;
-    private setupDom;
-    private handleResize;
-    private applyEventsSynchronously;
-    private getCastFn;
-    private handleInactivity;
-    private rebuildFullSnapshot;
-    private insertStyleRules;
-    private attachDocumentToIframe;
-    private collectIframeAndAttachDocument;
-    private waitForStylesheetLoad;
-    private hasImageArg;
-    private getImageArgs;
-    private preloadAllImages;
-    private preloadImages;
-    private applyIncremental;
-    private applyMutation;
-    private applyScroll;
-    private applyInput;
-    private legacy_resolveMissingNode;
-    private moveAndHover;
-    private drawMouseTail;
-    private hoverElements;
-    private isUserInteraction;
-    private backToNormal;
-    private restoreRealParent;
-    private storeState;
-    private restoreState;
-    private restoreNodeSheet;
-    private warnNodeNotFound;
-    private warnCanvasMutationFailed;
-    private debugNodeNotFound;
-    private warn;
-    private debug;
-}

package/dist/replay/machine.d.ts

@@ -1,85 +0,0 @@
-import { StateMachine } from '@xstate/fsm';
-import { playerConfig, eventWithTime, Emitter } from '../types';
-import { Timer } from './timer';
-export declare type PlayerContext = {
-    events: eventWithTime[];
-    timer: Timer;
-    timeOffset: number;
-    baselineTime: number;
-    lastPlayedEvent: eventWithTime | null;
-};
-export declare type PlayerEvent = {
-    type: 'PLAY';
-    payload: {
-        timeOffset: number;
-    };
-} | {
-    type: 'CAST_EVENT';
-    payload: {
-        event: eventWithTime;
-    };
-} | {
-    type: 'PAUSE';
-} | {
-    type: 'TO_LIVE';
-    payload: {
-        baselineTime?: number;
-    };
-} | {
-    type: 'ADD_EVENT';
-    payload: {
-        event: eventWithTime;
-    };
-} | {
-    type: 'REPLACE_EVENTS';
-    payload: {
-        events: eventWithTime[];
-    };
-} | {
-    type: 'END';
-};
-export declare type PlayerState = {
-    value: 'playing';
-    context: PlayerContext;
-} | {
-    value: 'paused';
-    context: PlayerContext;
-} | {
-    value: 'live';
-    context: PlayerContext;
-};
-export declare function discardPriorSnapshots(events: eventWithTime[], baselineTime: number): eventWithTime[];
-declare type PlayerAssets = {
-    emitter: Emitter;
-    applyEventsSynchronously(events: Array<eventWithTime>): void;
-    getCastFn(event: eventWithTime, isSync: boolean): () => void;
-};
-export declare function createPlayerService(context: PlayerContext, { getCastFn, applyEventsSynchronously, emitter }: PlayerAssets): StateMachine.Service<PlayerContext, PlayerEvent, PlayerState>;
-export declare type SpeedContext = {
-    normalSpeed: playerConfig['speed'];
-    timer: Timer;
-};
-export declare type SpeedEvent = {
-    type: 'FAST_FORWARD';
-    payload: {
-        speed: playerConfig['speed'];
-    };
-} | {
-    type: 'BACK_TO_NORMAL';
-} | {
-    type: 'SET_SPEED';
-    payload: {
-        speed: playerConfig['speed'];
-    };
-};
-export declare type SpeedState = {
-    value: 'normal';
-    context: SpeedContext;
-} | {
-    value: 'skipping';
-    context: SpeedContext;
-};
-export declare function createSpeedService(context: SpeedContext): StateMachine.Service<SpeedContext, SpeedEvent, SpeedState>;
-export declare type PlayerMachineState = StateMachine.State<PlayerContext, PlayerEvent, PlayerState>;
-export declare type SpeedMachineState = StateMachine.State<SpeedContext, SpeedEvent, SpeedState>;
-export {};

package/dist/replay/smoothscroll.d.ts

@@ -1 +0,0 @@
-export declare function polyfill(w?: Window, d?: Document): void;

package/dist/replay/styles/inject-style.d.ts

@@ -1,2 +0,0 @@
-declare const rules: (blockClass: string) => string[];
-export default rules;

package/dist/replay/timer.d.ts

@@ -1,19 +0,0 @@
-import { actionWithDelay, eventWithTime } from '../types';
-export declare class Timer {
-    timeOffset: number;
-    speed: number;
-    private actions;
-    private raf;
-    private liveMode;
-    constructor(actions: actionWithDelay[] | undefined, speed: number);
-    addAction(action: actionWithDelay): void;
-    addActions(actions: actionWithDelay[]): void;
-    replaceActions(actions: actionWithDelay[]): void;
-    start(): void;
-    clear(): void;
-    setSpeed(speed: number): void;
-    toggleLiveMode(mode: boolean): void;
-    isActive(): boolean;
-    private findActionIndex;
-}
-export declare function addDelay(event: eventWithTime, baselineTime: number): number;

package/dist/replay/virtual-styles.d.ts

@@ -1,43 +0,0 @@
-import { INode } from '../snapshot';
-export declare enum StyleRuleType {
-    Insert = 0,
-    Remove = 1,
-    Snapshot = 2,
-    SetProperty = 3,
-    RemoveProperty = 4
-}
-declare type InsertRule = {
-    cssText: string;
-    type: StyleRuleType.Insert;
-    index?: number | number[];
-};
-declare type RemoveRule = {
-    type: StyleRuleType.Remove;
-    index: number | number[];
-};
-declare type SnapshotRule = {
-    type: StyleRuleType.Snapshot;
-    cssTexts: string[];
-};
-declare type SetPropertyRule = {
-    type: StyleRuleType.SetProperty;
-    index: number[];
-    property: string;
-    value: string | null;
-    priority: string | undefined;
-};
-declare type RemovePropertyRule = {
-    type: StyleRuleType.RemoveProperty;
-    index: number[];
-    property: string;
-};
-export declare type VirtualStyleRules = Array<InsertRule | RemoveRule | SnapshotRule | SetPropertyRule | RemovePropertyRule>;
-export declare type VirtualStyleRulesMap = Map<INode, VirtualStyleRules>;
-export declare function getNestedRule(rules: CSSRuleList, position: number[]): CSSGroupingRule;
-export declare function getPositionsAndIndex(nestedIndex: number[]): {
-    positions: number[];
-    index: number | undefined;
-};
-export declare function applyVirtualStyleRulesToNode(storedRules: VirtualStyleRules, styleNode: HTMLStyleElement): void;
-export declare function storeCSSRules(parentElement: HTMLStyleElement, virtualStyleRulesMap: VirtualStyleRulesMap): void;
-export {};

package/dist/rrdom/index.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/rrdom/tree-node.d.ts

@@ -1,20 +0,0 @@
-export declare type AnyObject = {
-    [key: string]: any;
-    __rrdom__?: RRdomTreeNode;
-};
-export declare class RRdomTreeNode implements AnyObject {
-    parent: AnyObject | null;
-    previousSibling: AnyObject | null;
-    nextSibling: AnyObject | null;
-    firstChild: AnyObject | null;
-    lastChild: AnyObject | null;
-    childrenVersion: number;
-    childIndexCachedUpTo: AnyObject | null;
-    cachedIndex: number;
-    cachedIndexVersion: number;
-    get isAttached(): boolean;
-    get hasChildren(): boolean;
-    childrenChanged(): void;
-    getCachedIndex(parentNode: AnyObject): number;
-    setCachedIndex(parentNode: AnyObject, index: number): void;
-}