@kubesense/kubesense-browser-rum 1.8.0 → 2.0.0-beta.1

package/cjs/domain/record/mutationBatch.js

@@ -1,44 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MUTATION_PROCESS_MIN_DELAY = void 0;
-exports.createMutationBatch = createMutationBatch;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+//#region src/domain/record/mutationBatch.ts
 /**
- * Maximum duration to wait before processing mutations. If the browser is idle, mutations will be
- * processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the
- * mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the
- * browser is busy executing a longer task, mutations will be processed after this task.
- */
+* Maximum duration to wait before processing mutations. If the browser is idle, mutations will be
+* processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the
+* mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the
+* browser is busy executing a longer task, mutations will be processed after this task.
+*/
 const MUTATION_PROCESS_MAX_DELAY = 100;
-/**
- * Minimum duration to wait before processing mutations. This is used to batch mutations together
- * and be able to deduplicate them to save processing time and bandwidth.
- * 16ms is the duration of a frame at 60fps that ensure fluid UI.
- */
-exports.MUTATION_PROCESS_MIN_DELAY = 16;
 function createMutationBatch(processMutationBatch) {
-    let cancelScheduledFlush = kubesense_browser_core_1.noop;
-    let pendingMutations = [];
-    function flush() {
-        cancelScheduledFlush();
-        processMutationBatch(pendingMutations);
-        pendingMutations = [];
-    }
-    const { throttled: throttledFlush, cancel: cancelThrottle } = (0, kubesense_browser_core_1.throttle)(flush, exports.MUTATION_PROCESS_MIN_DELAY, {
-        leading: false,
-    });
-    return {
-        addMutations: (mutations) => {
-            if (pendingMutations.length === 0) {
-                cancelScheduledFlush = (0, kubesense_browser_core_1.requestIdleCallback)(throttledFlush, { timeout: MUTATION_PROCESS_MAX_DELAY });
-            }
-            pendingMutations.push(...mutations);
-        },
-        flush,
-        stop: () => {
-            cancelScheduledFlush();
-            cancelThrottle();
-        },
-    };
+	let cancelScheduledFlush = _kubesense_kubesense_browser_core.noop;
+	let pendingMutations = [];
+	let flushScheduled = false;
+	function scheduleFlush() {
+		if (!flushScheduled) {
+			flushScheduled = true;
+			cancelScheduledFlush = (0, _kubesense_kubesense_browser_core.requestIdleCallback)(throttledFlush, { timeout: MUTATION_PROCESS_MAX_DELAY });
+		}
+	}
+	function flush() {
+		cancelScheduledFlush();
+		flushScheduled = false;
+		processMutationBatch(pendingMutations);
+		pendingMutations = [];
+	}
+	const { throttled: throttledFlush, cancel: cancelThrottle } = (0, _kubesense_kubesense_browser_core.throttle)(flush, 16, { leading: false });
+	return {
+		addMutations: (mutations) => {
+			scheduleFlush();
+			for (const mutation of mutations) pendingMutations.push(mutation);
+		},
+		notifyContentMutated: scheduleFlush,
+		flush,
+		stop: () => {
+			cancelScheduledFlush();
+			cancelThrottle();
+		}
+	};
 }
+//#endregion
+exports.createMutationBatch = createMutationBatch;
+
 //# sourceMappingURL=mutationBatch.js.map

package/cjs/domain/record/mutationBatch.js.map

@@ -1 +1 @@
-{"version":3,"file":"mutationBatch.js","sourceRoot":"","sources":["../../../src/domain/record/mutationBatch.ts"],"names":[],"mappings":";;;AAiBA,kDA6BC;AA9CD,8EAAuF;AAGvF;;;;;GAKG;AACH,MAAM,0BAA0B,GAAG,GAAG,CAAA;AACtC;;;;GAIG;AACU,QAAA,0BAA0B,GAAG,EAAE,CAAA;AAE5C,SAAgB,mBAAmB,CAAC,oBAA8D;IAChG,IAAI,oBAAoB,GAAG,6BAAI,CAAA;IAC/B,IAAI,gBAAgB,GAAwB,EAAE,CAAA;IAE9C,SAAS,KAAK;QACZ,oBAAoB,EAAE,CAAA;QACtB,oBAAoB,CAAC,gBAAgB,CAAC,CAAA;QACtC,gBAAgB,GAAG,EAAE,CAAA;IACvB,CAAC;IAED,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,IAAA,iCAAQ,EAAC,KAAK,EAAE,kCAA0B,EAAE;QACxG,OAAO,EAAE,KAAK;KACf,CAAC,CAAA;IAEF,OAAO;QACL,YAAY,EAAE,CAAC,SAA8B,EAAE,EAAE;YAC/C,IAAI,gBAAgB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAClC,oBAAoB,GAAG,IAAA,4CAAmB,EAAC,cAAc,EAAE,EAAE,OAAO,EAAE,0BAA0B,EAAE,CAAC,CAAA;YACrG,CAAC;YACD,gBAAgB,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,CAAA;QACrC,CAAC;QAED,KAAK;QAEL,IAAI,EAAE,GAAG,EAAE;YACT,oBAAoB,EAAE,CAAA;YACtB,cAAc,EAAE,CAAA;QAClB,CAAC;KACF,CAAA;AACH,CAAC"}
+{"version":3,"file":"mutationBatch.js","names":["noop","requestIdleCallback","throttle"],"sources":["../../../src/domain/record/mutationBatch.ts"],"sourcesContent":["import { noop, throttle, requestIdleCallback } from '@kubesense/kubesense-browser-core'\nimport type { RumMutationRecord } from '@kubesense/kubesense-browser-rum-core'\n\n/**\n * Maximum duration to wait before processing mutations. If the browser is idle, mutations will be\n * processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the\n * mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the\n * browser is busy executing a longer task, mutations will be processed after this task.\n */\nconst MUTATION_PROCESS_MAX_DELAY = 100\n/**\n * Minimum duration to wait before processing mutations. This is used to batch mutations together\n * and be able to deduplicate them to save processing time and bandwidth.\n * 16ms is the duration of a frame at 60fps that ensure fluid UI.\n */\nexport const MUTATION_PROCESS_MIN_DELAY = 16\n\nexport function createMutationBatch(processMutationBatch: (mutations: RumMutationRecord[]) => void) {\n  let cancelScheduledFlush = noop\n  let pendingMutations: RumMutationRecord[] = []\n  let flushScheduled = false\n\n  function scheduleFlush() {\n    if (!flushScheduled) {\n      flushScheduled = true\n      cancelScheduledFlush = requestIdleCallback(throttledFlush, { timeout: MUTATION_PROCESS_MAX_DELAY })\n    }\n  }\n\n  function flush() {\n    cancelScheduledFlush()\n    flushScheduled = false\n    processMutationBatch(pendingMutations)\n    pendingMutations = []\n  }\n\n  const { throttled: throttledFlush, cancel: cancelThrottle } = throttle(flush, MUTATION_PROCESS_MIN_DELAY, {\n    leading: false,\n  })\n\n  return {\n    addMutations: (mutations: RumMutationRecord[]) => {\n      scheduleFlush()\n      for (const mutation of mutations) {\n        pendingMutations.push(mutation)\n      }\n    },\n\n    notifyContentMutated: scheduleFlush,\n\n    flush,\n\n    stop: () => {\n      cancelScheduledFlush()\n      cancelThrottle()\n    },\n  }\n}\n"],"mappings":";;;;;;;;AASA,MAAM,6BAA6B;AAQnC,SAAgB,oBAAoB,sBAAgE;CAClG,IAAI,uBAAuBA,kCAAAA;CAC3B,IAAI,mBAAwC,CAAC;CAC7C,IAAI,iBAAiB;CAErB,SAAS,gBAAgB;EACvB,IAAI,CAAC,gBAAgB;GACnB,iBAAiB;GACjB,wBAAA,GAAuBC,kCAAAA,oBAAAA,CAAoB,gBAAgB,EAAE,SAAS,2BAA2B,CAAC;EACpG;CACF;CAEA,SAAS,QAAQ;EACf,qBAAqB;EACrB,iBAAiB;EACjB,qBAAqB,gBAAgB;EACrC,mBAAmB,CAAC;CACtB;CAEA,MAAM,EAAE,WAAW,gBAAgB,QAAQ,oBAAA,GAAmBC,kCAAAA,SAAAA,CAAS,OAAA,IAAmC,EACxG,SAAS,MACX,CAAC;CAED,OAAO;EACL,eAAe,cAAmC;GAChD,cAAc;GACd,KAAK,MAAM,YAAY,WACrB,iBAAiB,KAAK,QAAQ;EAElC;EAEA,sBAAsB;EAEtB;EAEA,YAAY;GACV,qBAAqB;GACrB,eAAe;EACjB;CACF;AACF"}

package/cjs/domain/record/record.d.ts

@@ -1,8 +1,9 @@
 import type { LifeCycle, RumConfiguration, ViewHistory } from '@kubesense/kubesense-browser-rum-core';
 import type { ShadowRootsController } from './shadowRootsController';
-import type { EmitRecordCallback, EmitStatsCallback } from './record.types';
+import type { EmitRecordCallback, EmitStatsCallback, EmitResourceCallback } from './record.types';
 export interface RecordOptions {
     emitRecord: EmitRecordCallback;
+    emitResource: EmitResourceCallback;
     emitStats: EmitStatsCallback;
     configuration: RumConfiguration;
     lifeCycle: LifeCycle;
@@ -12,5 +13,10 @@ export interface RecordAPI {
     stop: () => void;
     flushMutations: () => void;
     shadowRootsController: ShadowRootsController;
+    /**
+     * Starts the record stream over with a new full snapshot, so replay can recover when records
+     * already emitted never reached the intake.
+     */
+    takeFullSnapshot: () => void;
 }
 export declare function record(options: RecordOptions): RecordAPI;

package/cjs/domain/record/record.js

@@ -1,90 +1,79 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.record = record;
-const kubesense_browser_core_1 = require("@kubesense/kubesense-browser-core");
-const replayStats = __importStar(require("../replayStats"));
-const trackers_1 = require("./trackers");
-const elementsScrollPositions_1 = require("./elementsScrollPositions");
-const shadowRootsController_1 = require("./shadowRootsController");
-const startFullSnapshots_1 = require("./startFullSnapshots");
-const eventIds_1 = require("./eventIds");
-const nodeIds_1 = require("./nodeIds");
-const recordingScope_1 = require("./recordingScope");
+const require_canvasManager = require("./canvas/canvasManager.js");
+require("./serialization/index.js");
+const require_startFullSnapshots = require("./startFullSnapshots.js");
+const require_recordingScope = require("./recordingScope.js");
+const require_elementsScrollPositions = require("./elementsScrollPositions.js");
+const require_replayStats = require("../replayStats.js");
+const require_trackMove = require("./trackers/trackMove.js");
+const require_trackMouseInteraction = require("./trackers/trackMouseInteraction.js");
+const require_trackScroll = require("./trackers/trackScroll.js");
+const require_trackViewportResize = require("./trackers/trackViewportResize.js");
+const require_trackMediaInteraction = require("./trackers/trackMediaInteraction.js");
+const require_trackStyleSheet = require("./trackers/trackStyleSheet.js");
+const require_trackFocus = require("./trackers/trackFocus.js");
+const require_trackViewEnd = require("./trackers/trackViewEnd.js");
+const require_trackInput = require("./trackers/trackInput.js");
+const require_trackMutation = require("./trackers/trackMutation.js");
+const require_trackCanvasContent = require("./trackers/trackCanvasContent.js");
+const require_trackCanvasCapture = require("./trackers/trackCanvasCapture.js");
+require("./trackers/index.js");
+const require_shadowRootsController = require("./shadowRootsController.js");
+let _kubesense_kubesense_browser_core = require("@kubesense/kubesense-browser-core");
+let _kubesense_kubesense_js_core_time = require("@kubesense/kubesense-js-core/time");
+//#region src/domain/record/record.ts
 function record(options) {
-    const { emitRecord, emitStats, configuration, lifeCycle } = options;
-    // runtime checks for user options
-    if (!emitRecord || !emitStats) {
-        throw new Error('emit functions are required');
-    }
-    const processRecord = (record) => {
-        emitRecord(record);
-        (0, kubesense_browser_core_1.sendToExtension)('record', { record });
-        const view = options.viewHistory.findView();
-        replayStats.addRecord(view.id);
-    };
-    const shadowRootsController = (0, shadowRootsController_1.initShadowRootsController)(processRecord, emitStats);
-    const scope = (0, recordingScope_1.createRecordingScope)(configuration, (0, elementsScrollPositions_1.createElementsScrollPositions)(), (0, eventIds_1.createEventIds)(), (0, nodeIds_1.createNodeIds)(), shadowRootsController);
-    const { stop: stopFullSnapshots } = (0, startFullSnapshots_1.startFullSnapshots)(lifeCycle, processRecord, emitStats, flushMutations, scope);
-    function flushMutations() {
-        shadowRootsController.flush();
-        mutationTracker.flush();
-    }
-    const mutationTracker = (0, trackers_1.trackMutation)(document, processRecord, emitStats, scope);
-    const trackers = [
-        mutationTracker,
-        (0, trackers_1.trackMove)(processRecord, scope),
-        (0, trackers_1.trackMouseInteraction)(processRecord, scope),
-        (0, trackers_1.trackScroll)(document, processRecord, scope),
-        (0, trackers_1.trackViewportResize)(processRecord, scope),
-        (0, trackers_1.trackInput)(document, processRecord, scope),
-        (0, trackers_1.trackMediaInteraction)(processRecord, scope),
-        (0, trackers_1.trackStyleSheet)(processRecord, scope),
-        (0, trackers_1.trackFocus)(processRecord, scope),
-        (0, trackers_1.trackVisualViewportResize)(processRecord, scope),
-        (0, trackers_1.trackFrustration)(lifeCycle, processRecord, scope),
-        (0, trackers_1.trackViewEnd)(lifeCycle, processRecord, flushMutations),
-    ];
-    return {
-        stop: () => {
-            shadowRootsController.stop();
-            trackers.forEach((tracker) => tracker.stop());
-            stopFullSnapshots();
-        },
-        flushMutations,
-        shadowRootsController,
-    };
+	const { emitRecord, emitResource, emitStats, configuration, lifeCycle } = options;
+	if (!emitRecord || !emitResource || !emitStats) throw new Error("emit functions are required");
+	const processRecord = (record) => {
+		emitRecord(record);
+		(0, _kubesense_kubesense_browser_core.sendToExtension)("record", { record });
+		const view = options.viewHistory.findView();
+		require_replayStats.addRecord(view.id);
+	};
+	const processResource = (hash, content, onDiscard) => {
+		emitResource(hash, content, onDiscard);
+		const view = options.viewHistory.findView();
+		require_replayStats.addResource(view.id);
+	};
+	const canvasManager = require_canvasManager.createCanvasManager();
+	const shadowRootsController = require_shadowRootsController.initShadowRootsController(processRecord, processResource, emitStats);
+	const scope = require_recordingScope.createRecordingScope(canvasManager, configuration, require_elementsScrollPositions.createElementsScrollPositions(), shadowRootsController);
+	const { stop: stopFullSnapshots } = require_startFullSnapshots.startFullSnapshots(lifeCycle, processRecord, emitStats, flushMutations, scope);
+	function flushMutations() {
+		shadowRootsController.flush();
+		mutationTracker.flush();
+	}
+	const mutationTracker = require_trackMutation.trackMutation(document, processRecord, processResource, emitStats, scope);
+	const trackers = [
+		mutationTracker,
+		require_trackMove.trackMove(processRecord, scope),
+		require_trackMouseInteraction.trackMouseInteraction(processRecord, scope),
+		require_trackScroll.trackScroll(document, processRecord, scope),
+		require_trackViewportResize.trackViewportResize(processRecord),
+		require_trackInput.trackInput(document, processRecord, emitStats, scope),
+		require_trackMediaInteraction.trackMediaInteraction(processRecord, scope),
+		require_trackStyleSheet.trackStyleSheet(processRecord, scope),
+		require_trackFocus.trackFocus(processRecord),
+		require_trackViewportResize.trackVisualViewportResize(processRecord),
+		require_trackViewEnd.trackViewEnd(lifeCycle, processRecord, flushMutations),
+		require_trackCanvasContent.trackCanvasContent(scope),
+		require_trackCanvasCapture.trackCanvasCapture(scope, mutationTracker.notifyContentMutated)
+	];
+	return {
+		stop: () => {
+			shadowRootsController.stop();
+			trackers.forEach((tracker) => tracker.stop());
+			stopFullSnapshots();
+		},
+		flushMutations,
+		shadowRootsController,
+		takeFullSnapshot: () => {
+			flushMutations();
+			require_startFullSnapshots.takeFullSnapshot((0, _kubesense_kubesense_js_core_time.timeStampNow)(), 1, processRecord, emitStats, scope);
+		}
+	};
 }
+//#endregion
+exports.record = record;
+
 //# sourceMappingURL=record.js.map

package/cjs/domain/record/record.js.map

@@ -1 +1 @@
-{"version":3,"file":"record.js","sourceRoot":"","sources":["../../../src/domain/record/record.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,wBAuDC;AAjGD,8EAAmE;AAEnE,4DAA6C;AAG7C,yCAamB;AACnB,uEAAyE;AAEzE,mEAAmE;AACnE,6DAAyD;AACzD,yCAA2C;AAC3C,uCAAyC;AAEzC,qDAAuD;AAgBvD,SAAgB,MAAM,CAAC,OAAsB;IAC3C,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,GAAG,OAAO,CAAA;IACnE,kCAAkC;IAClC,IAAI,CAAC,UAAU,IAAI,CAAC,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAA;IAChD,CAAC;IAED,MAAM,aAAa,GAAuB,CAAC,MAAqB,EAAE,EAAE;QAClE,UAAU,CAAC,MAAM,CAAC,CAAA;QAClB,IAAA,wCAAe,EAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,CAAC,CAAA;QACrC,MAAM,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAG,CAAA;QAC5C,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;IAChC,CAAC,CAAA;IAED,MAAM,qBAAqB,GAAG,IAAA,iDAAyB,EAAC,aAAa,EAAE,SAAS,CAAC,CAAA;IACjF,MAAM,KAAK,GAAG,IAAA,qCAAoB,EAChC,aAAa,EACb,IAAA,uDAA6B,GAAE,EAC/B,IAAA,yBAAc,GAAE,EAChB,IAAA,uBAAa,GAAE,EACf,qBAAqB,CACtB,CAAA;IAED,MAAM,EAAE,IAAI,EAAE,iBAAiB,EAAE,GAAG,IAAA,uCAAkB,EAAC,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,cAAc,EAAE,KAAK,CAAC,CAAA;IAElH,SAAS,cAAc;QACrB,qBAAqB,CAAC,KAAK,EAAE,CAAA;QAC7B,eAAe,CAAC,KAAK,EAAE,CAAA;IACzB,CAAC;IAED,MAAM,eAAe,GAAG,IAAA,wBAAa,EAAC,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,KAAK,CAAC,CAAA;IAChF,MAAM,QAAQ,GAAc;QAC1B,eAAe;QACf,IAAA,oBAAS,EAAC,aAAa,EAAE,KAAK,CAAC;QAC/B,IAAA,gCAAqB,EAAC,aAAa,EAAE,KAAK,CAAC;QAC3C,IAAA,sBAAW,EAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,CAAC;QAC3C,IAAA,8BAAmB,EAAC,aAAa,EAAE,KAAK,CAAC;QACzC,IAAA,qBAAU,EAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,CAAC;QAC1C,IAAA,gCAAqB,EAAC,aAAa,EAAE,KAAK,CAAC;QAC3C,IAAA,0BAAe,EAAC,aAAa,EAAE,KAAK,CAAC;QACrC,IAAA,qBAAU,EAAC,aAAa,EAAE,KAAK,CAAC;QAChC,IAAA,oCAAyB,EAAC,aAAa,EAAE,KAAK,CAAC;QAC/C,IAAA,2BAAgB,EAAC,SAAS,EAAE,aAAa,EAAE,KAAK,CAAC;QACjD,IAAA,uBAAY,EAAC,SAAS,EAAE,aAAa,EAAE,cAAc,CAAC;KACvD,CAAA;IAED,OAAO;QACL,IAAI,EAAE,GAAG,EAAE;YACT,qBAAqB,CAAC,IAAI,EAAE,CAAA;YAC5B,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAA;YAC7C,iBAAiB,EAAE,CAAA;QACrB,CAAC;QACD,cAAc;QACd,qBAAqB;KACtB,CAAA;AACH,CAAC"}
+{"version":3,"file":"record.js","names":["createCanvasManager","initShadowRootsController","createRecordingScope","createElementsScrollPositions","startFullSnapshots","trackMutation","trackMove","trackMouseInteraction","trackScroll","trackViewportResize","trackInput","trackMediaInteraction","trackStyleSheet","trackFocus","trackVisualViewportResize","trackViewEnd","trackCanvasContent","trackCanvasCapture","timeStampNow"],"sources":["../../../src/domain/record/record.ts"],"sourcesContent":["import { sendToExtension } from '@kubesense/kubesense-browser-core'\nimport { timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport type { LifeCycle, RumConfiguration, ViewHistory } from '@kubesense/kubesense-browser-rum-core'\nimport * as replayStats from '../replayStats'\nimport type { BrowserRecord } from '../../types'\nimport type { Tracker } from './trackers'\nimport {\n  trackFocus,\n  trackInput,\n  trackMediaInteraction,\n  trackMouseInteraction,\n  trackMove,\n  trackMutation,\n  trackScroll,\n  trackStyleSheet,\n  trackViewEnd,\n  trackViewportResize,\n  trackVisualViewportResize,\n  trackCanvasContent,\n  trackCanvasCapture,\n} from './trackers'\nimport { createElementsScrollPositions } from './elementsScrollPositions'\nimport type { ShadowRootsController } from './shadowRootsController'\nimport { initShadowRootsController } from './shadowRootsController'\nimport { startFullSnapshots, takeFullSnapshot } from './startFullSnapshots'\nimport type { EmitRecordCallback, EmitStatsCallback, EmitResourceCallback } from './record.types'\nimport { createRecordingScope } from './recordingScope'\nimport { createCanvasManager } from './canvas/canvasManager'\nimport { SerializationKind } from './serialization'\n\nexport interface RecordOptions {\n  emitRecord: EmitRecordCallback\n  emitResource: EmitResourceCallback\n  emitStats: EmitStatsCallback\n  configuration: RumConfiguration\n  lifeCycle: LifeCycle\n  viewHistory: ViewHistory\n}\n\nexport interface RecordAPI {\n  stop: () => void\n  flushMutations: () => void\n  shadowRootsController: ShadowRootsController\n  /**\n   * Starts the record stream over with a new full snapshot, so replay can recover when records\n   * already emitted never reached the intake.\n   */\n  takeFullSnapshot: () => void\n}\n\nexport function record(options: RecordOptions): RecordAPI {\n  const { emitRecord, emitResource, emitStats, configuration, lifeCycle } = options\n  // runtime checks for user options\n  if (!emitRecord || !emitResource || !emitStats) {\n    throw new Error('emit functions are required')\n  }\n\n  const processRecord: EmitRecordCallback = (record: BrowserRecord) => {\n    emitRecord(record)\n    sendToExtension('record', { record })\n    const view = options.viewHistory.findView()!\n    replayStats.addRecord(view.id)\n  }\n\n  const processResource: EmitResourceCallback = (hash, content, onDiscard) => {\n    emitResource(hash, content, onDiscard)\n    const view = options.viewHistory.findView()!\n    replayStats.addResource(view.id)\n  }\n\n  const canvasManager = createCanvasManager()\n  const shadowRootsController = initShadowRootsController(processRecord, processResource, emitStats)\n  const scope = createRecordingScope(\n    canvasManager,\n    configuration,\n    createElementsScrollPositions(),\n    shadowRootsController\n  )\n\n  const { stop: stopFullSnapshots } = startFullSnapshots(lifeCycle, processRecord, emitStats, flushMutations, scope)\n\n  function flushMutations() {\n    shadowRootsController.flush()\n    mutationTracker.flush()\n  }\n\n  const mutationTracker = trackMutation(document, processRecord, processResource, emitStats, scope)\n  const trackers: Tracker[] = [\n    mutationTracker,\n    trackMove(processRecord, scope),\n    trackMouseInteraction(processRecord, scope),\n    trackScroll(document, processRecord, scope),\n    trackViewportResize(processRecord),\n    trackInput(document, processRecord, emitStats, scope),\n    trackMediaInteraction(processRecord, scope),\n    trackStyleSheet(processRecord, scope),\n    trackFocus(processRecord),\n    trackVisualViewportResize(processRecord),\n    trackViewEnd(lifeCycle, processRecord, flushMutations),\n    trackCanvasContent(scope),\n    trackCanvasCapture(scope, mutationTracker.notifyContentMutated),\n  ]\n\n  return {\n    stop: () => {\n      shadowRootsController.stop()\n      trackers.forEach((tracker) => tracker.stop())\n      stopFullSnapshots()\n    },\n    flushMutations,\n    shadowRootsController,\n    takeFullSnapshot: () => {\n      flushMutations()\n      takeFullSnapshot(timeStampNow(), SerializationKind.SUBSEQUENT_FULL_SNAPSHOT, processRecord, emitStats, scope)\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,OAAO,SAAmC;CACxD,MAAM,EAAE,YAAY,cAAc,WAAW,eAAe,cAAc;CAE1E,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,WACnC,MAAM,IAAI,MAAM,6BAA6B;CAG/C,MAAM,iBAAqC,WAA0B;EACnE,WAAW,MAAM;EACjB,CAAA,GAAA,kCAAA,gBAAA,CAAgB,UAAU,EAAE,OAAO,CAAC;EACpC,MAAM,OAAO,QAAQ,YAAY,SAAS;EAC1C,oBAAA,UAAsB,KAAK,EAAE;CAC/B;CAEA,MAAM,mBAAyC,MAAM,SAAS,cAAc;EAC1E,aAAa,MAAM,SAAS,SAAS;EACrC,MAAM,OAAO,QAAQ,YAAY,SAAS;EAC1C,oBAAA,YAAwB,KAAK,EAAE;CACjC;CAEA,MAAM,gBAAgBA,sBAAAA,oBAAoB;CAC1C,MAAM,wBAAwBC,8BAAAA,0BAA0B,eAAe,iBAAiB,SAAS;CACjG,MAAM,QAAQC,uBAAAA,qBACZ,eACA,eACAC,gCAAAA,8BAA8B,GAC9B,qBACF;CAEA,MAAM,EAAE,MAAM,sBAAsBC,2BAAAA,mBAAmB,WAAW,eAAe,WAAW,gBAAgB,KAAK;CAEjH,SAAS,iBAAiB;EACxB,sBAAsB,MAAM;EAC5B,gBAAgB,MAAM;CACxB;CAEA,MAAM,kBAAkBC,sBAAAA,cAAc,UAAU,eAAe,iBAAiB,WAAW,KAAK;CAChG,MAAM,WAAsB;EAC1B;EACAC,kBAAAA,UAAU,eAAe,KAAK;EAC9BC,8BAAAA,sBAAsB,eAAe,KAAK;EAC1CC,oBAAAA,YAAY,UAAU,eAAe,KAAK;EAC1CC,4BAAAA,oBAAoB,aAAa;EACjCC,mBAAAA,WAAW,UAAU,eAAe,WAAW,KAAK;EACpDC,8BAAAA,sBAAsB,eAAe,KAAK;EAC1CC,wBAAAA,gBAAgB,eAAe,KAAK;EACpCC,mBAAAA,WAAW,aAAa;EACxBC,4BAAAA,0BAA0B,aAAa;EACvCC,qBAAAA,aAAa,WAAW,eAAe,cAAc;EACrDC,2BAAAA,mBAAmB,KAAK;EACxBC,2BAAAA,mBAAmB,OAAO,gBAAgB,oBAAoB;CAChE;CAEA,OAAO;EACL,YAAY;GACV,sBAAsB,KAAK;GAC3B,SAAS,SAAS,YAAY,QAAQ,KAAK,CAAC;GAC5C,kBAAkB;EACpB;EACA;EACA;EACA,wBAAwB;GACtB,eAAe;GACf,2BAAA,kBAAA,GAAiBC,kCAAAA,aAAAA,CAAa,GAAA,GAA+C,eAAe,WAAW,KAAK;EAC9G;CACF;AACF"}

package/cjs/domain/record/record.types.d.ts

@@ -1,4 +1,5 @@
 import type { BrowserRecord } from '../../types';
 import type { SerializationStats } from './serialization';
 export type EmitRecordCallback<Record extends BrowserRecord = BrowserRecord> = (record: Record) => void;
+export type EmitResourceCallback = (hash: string, content: Blob, onDiscard?: () => void) => void;
 export type EmitStatsCallback = (stats: SerializationStats) => void;

package/cjs/domain/record/recordingScope.d.ts

@@ -1,8 +1,8 @@
 import type { RumConfiguration } from '@kubesense/kubesense-browser-rum-core';
 import type { ElementsScrollPositions } from './elementsScrollPositions';
-import type { EventIds } from './eventIds';
-import type { NodeIds } from './nodeIds';
+import type { EventIds, NodeIds, StringIds, StyleSheetIds } from './encoding';
 import type { ShadowRootsController } from './shadowRootsController';
+import type { CanvasManager } from './canvas/canvasManager';
 /**
  * State associated with a stream of session replay records. When a new stream of records
  * starts (e.g. because recording has shut down and restarted), a new RecordingScope
@@ -10,10 +10,14 @@ import type { ShadowRootsController } from './shadowRootsController';
  * or data which aren't present in the current stream.
  */
 export interface RecordingScope {
+    resetIds(): void;
+    canvasManager: CanvasManager;
     configuration: RumConfiguration;
     elementsScrollPositions: ElementsScrollPositions;
     eventIds: EventIds;
     nodeIds: NodeIds;
     shadowRootsController: ShadowRootsController;
+    stringIds: StringIds;
+    styleSheetIds: StyleSheetIds;
 }
-export declare function createRecordingScope(configuration: RumConfiguration, elementsScrollPositions: ElementsScrollPositions, eventIds: EventIds, nodeIds: NodeIds, shadowRootsController: ShadowRootsController): RecordingScope;
+export declare function createRecordingScope(canvasManager: CanvasManager, configuration: RumConfiguration, elementsScrollPositions: ElementsScrollPositions, shadowRootsController: ShadowRootsController): RecordingScope;

package/cjs/domain/record/recordingScope.js

@@ -1,13 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRecordingScope = createRecordingScope;
-function createRecordingScope(configuration, elementsScrollPositions, eventIds, nodeIds, shadowRootsController) {
-    return {
-        configuration,
-        elementsScrollPositions,
-        eventIds,
-        nodeIds,
-        shadowRootsController,
-    };
+const require_stringIds = require("./encoding/stringIds.js");
+const require_itemIds = require("./encoding/itemIds.js");
+//#region src/domain/record/recordingScope.ts
+function createRecordingScope(canvasManager, configuration, elementsScrollPositions, shadowRootsController) {
+	const scope = {
+		resetIds() {
+			scope.eventIds.clear();
+			scope.nodeIds.clear();
+			scope.stringIds.clear();
+			scope.styleSheetIds.clear();
+			scope.canvasManager.reset();
+		},
+		canvasManager,
+		configuration,
+		elementsScrollPositions,
+		eventIds: require_itemIds.createEventIds(),
+		nodeIds: require_itemIds.createNodeIds(),
+		shadowRootsController,
+		stringIds: require_stringIds.createStringIds(),
+		styleSheetIds: require_itemIds.createStyleSheetIds()
+	};
+	return scope;
 }
+//#endregion
+exports.createRecordingScope = createRecordingScope;
+
 //# sourceMappingURL=recordingScope.js.map

package/cjs/domain/record/recordingScope.js.map

@@ -1 +1 @@
-{"version":3,"file":"recordingScope.js","sourceRoot":"","sources":["../../../src/domain/record/recordingScope.ts"],"names":[],"mappings":";;AAqBA,oDAcC;AAdD,SAAgB,oBAAoB,CAClC,aAA+B,EAC/B,uBAAgD,EAChD,QAAkB,EAClB,OAAgB,EAChB,qBAA4C;IAE5C,OAAO;QACL,aAAa;QACb,uBAAuB;QACvB,QAAQ;QACR,OAAO;QACP,qBAAqB;KACtB,CAAA;AACH,CAAC"}
+{"version":3,"file":"recordingScope.js","names":["createEventIds","createNodeIds","createStringIds","createStyleSheetIds"],"sources":["../../../src/domain/record/recordingScope.ts"],"sourcesContent":["import type { RumConfiguration } from '@kubesense/kubesense-browser-rum-core'\n\nimport type { ElementsScrollPositions } from './elementsScrollPositions'\nimport { createEventIds, createNodeIds, createStringIds, createStyleSheetIds } from './encoding'\nimport type { EventIds, NodeIds, StringIds, StyleSheetIds } from './encoding'\nimport type { ShadowRootsController } from './shadowRootsController'\nimport type { CanvasManager } from './canvas/canvasManager'\n\n/**\n * State associated with a stream of session replay records. When a new stream of records\n * starts (e.g. because recording has shut down and restarted), a new RecordingScope\n * object must be created; this ensures that we don't generate records that reference ids\n * or data which aren't present in the current stream.\n */\nexport interface RecordingScope {\n  resetIds(): void\n\n  canvasManager: CanvasManager\n  configuration: RumConfiguration\n  elementsScrollPositions: ElementsScrollPositions\n  eventIds: EventIds\n  nodeIds: NodeIds\n  shadowRootsController: ShadowRootsController\n  stringIds: StringIds\n  styleSheetIds: StyleSheetIds\n}\n\nexport function createRecordingScope(\n  canvasManager: CanvasManager,\n  configuration: RumConfiguration,\n  elementsScrollPositions: ElementsScrollPositions,\n  shadowRootsController: ShadowRootsController\n): RecordingScope {\n  const eventIds = createEventIds()\n  const nodeIds = createNodeIds()\n  const stringIds = createStringIds()\n  const styleSheetIds = createStyleSheetIds()\n\n  const scope: RecordingScope = {\n    resetIds(): void {\n      scope.eventIds.clear()\n      scope.nodeIds.clear()\n      scope.stringIds.clear()\n      scope.styleSheetIds.clear()\n      scope.canvasManager.reset()\n    },\n\n    canvasManager,\n    configuration,\n    elementsScrollPositions,\n    eventIds,\n    nodeIds,\n    shadowRootsController,\n    stringIds,\n    styleSheetIds,\n  }\n\n  return scope\n}\n"],"mappings":";;;AA2BA,SAAgB,qBACd,eACA,eACA,yBACA,uBACgB;CAMhB,MAAM,QAAwB;EAC5B,WAAiB;GACf,MAAM,SAAS,MAAM;GACrB,MAAM,QAAQ,MAAM;GACpB,MAAM,UAAU,MAAM;GACtB,MAAM,cAAc,MAAM;GAC1B,MAAM,cAAc,MAAM;EAC5B;EAEA;EACA;EACA;EACA,UAjBeA,gBAAAA,eAiBR;EACP,SAjBcC,gBAAAA,cAiBR;EACN;EACA,WAlBgBC,kBAAAA,gBAkBR;EACR,eAlBoBC,gBAAAA,oBAkBR;CACd;CAEA,OAAO;AACT"}

package/cjs/domain/record/serialization/index.d.ts

@@ -1,8 +1,10 @@
+export { createChildInsertionCursor, createRootInsertionCursor } from './insertionCursor';
 export { getElementInputValue } from './serializationUtils';
-export { serializeDocument } from './serializeDocument';
+export { serializeFullSnapshot } from './serializeFullSnapshot';
+export { serializeMutations } from './serializeMutations';
 export { serializeNode } from './serializeNode';
 export { serializeAttribute } from './serializeAttribute';
 export { createSerializationStats, updateSerializationStats, aggregateSerializationStats } from './serializationStats';
 export type { SerializationMetric, SerializationStats } from './serializationStats';
 export { serializeInTransaction, SerializationKind } from './serializationTransaction';
-export type { SerializationTransaction, SerializationTransactionCallback } from './serializationTransaction';
+export type { SerializationTransaction } from './serializationTransaction';

package/cjs/domain/record/serialization/index.js

@@ -1,18 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeInTransaction = exports.aggregateSerializationStats = exports.updateSerializationStats = exports.createSerializationStats = exports.serializeAttribute = exports.serializeNode = exports.serializeDocument = exports.getElementInputValue = void 0;
-var serializationUtils_1 = require("./serializationUtils");
-Object.defineProperty(exports, "getElementInputValue", { enumerable: true, get: function () { return serializationUtils_1.getElementInputValue; } });
-var serializeDocument_1 = require("./serializeDocument");
-Object.defineProperty(exports, "serializeDocument", { enumerable: true, get: function () { return serializeDocument_1.serializeDocument; } });
-var serializeNode_1 = require("./serializeNode");
-Object.defineProperty(exports, "serializeNode", { enumerable: true, get: function () { return serializeNode_1.serializeNode; } });
-var serializeAttribute_1 = require("./serializeAttribute");
-Object.defineProperty(exports, "serializeAttribute", { enumerable: true, get: function () { return serializeAttribute_1.serializeAttribute; } });
-var serializationStats_1 = require("./serializationStats");
-Object.defineProperty(exports, "createSerializationStats", { enumerable: true, get: function () { return serializationStats_1.createSerializationStats; } });
-Object.defineProperty(exports, "updateSerializationStats", { enumerable: true, get: function () { return serializationStats_1.updateSerializationStats; } });
-Object.defineProperty(exports, "aggregateSerializationStats", { enumerable: true, get: function () { return serializationStats_1.aggregateSerializationStats; } });
-var serializationTransaction_1 = require("./serializationTransaction");
-Object.defineProperty(exports, "serializeInTransaction", { enumerable: true, get: function () { return serializationTransaction_1.serializeInTransaction; } });
-//# sourceMappingURL=index.js.map
+const require_insertionCursor = require("./insertionCursor.js");
+const require_serializationUtils = require("./serializationUtils.js");
+const require_serializationStats = require("./serializationStats.js");
+const require_serializationTransaction = require("./serializationTransaction.js");
+require("./serializeAttribute.js");
+const require_serializeNode = require("./serializeNode.js");
+const require_serializeFullSnapshot = require("./serializeFullSnapshot.js");
+const require_serializeMutations = require("./serializeMutations.js");
+exports.aggregateSerializationStats = require_serializationStats.aggregateSerializationStats;
+exports.createRootInsertionCursor = require_insertionCursor.createRootInsertionCursor;
+exports.createSerializationStats = require_serializationStats.createSerializationStats;
+exports.getElementInputValue = require_serializationUtils.getElementInputValue;
+exports.serializeFullSnapshot = require_serializeFullSnapshot.serializeFullSnapshot;
+exports.serializeInTransaction = require_serializationTransaction.serializeInTransaction;
+exports.serializeMutations = require_serializeMutations.serializeMutations;
+exports.serializeNode = require_serializeNode.serializeNode;

package/cjs/domain/record/serialization/insertionCursor.d.ts

@@ -0,0 +1,57 @@
+import type { InsertionPoint } from '../../../types';
+import type { NodeId, NodeIds } from '../encoding';
+/**
+ * InsertionCursor tracks the point at which the next node will be inserted during
+ * Change-style DOM serialization.
+ *
+ * When a new node is added to the document, we use an InsertionPoint to encode its
+ * position. There are often multiple equally-valid ways to express the same insertion
+ * point; we generally want to favor encodings that use as few characters as possible (to
+ * reduce uncompressed size) and that are as repetitive as possible (to reduce compressed
+ * size). InsertionCursor's purpose is to heuristically pick an efficient encoding based
+ * on the nodes we've recently serialized, while doing as little work as possible. The
+ * results are not optimal, but should be close to it in most situations.
+ *
+ * At the beginning of the serialization process, use a factory function like
+ * createRootInsertionCursor() to create a new cursor with an appropriate initial
+ * position.
+ *
+ * When visiting a node, the expected usage pattern is as follows:
+ * 1. Call advance() to get a node id and insertion point for the node.
+ * 2. Serialize the node.
+ * 3. If the node has no children, we're done; continue to the node's next
+ * sibling and apply this algorithm again.
+ * 4. Otherwise, call descend() to move the cursor into the node's child list.
+ * 5. Recursively apply this algorithm.
+ * 6. Call ascend() to move the cursor out of the node's child list. We're done;
+ * continue to the node's next sibling and apply this algorithm again.
+ */
+export interface InsertionCursor {
+    /**
+     * Given the node id for a new node, returns the InsertionPoint for that node.
+     * Updates the cursor to point to the new node's next sibling.
+     */
+    advance(node: Node): {
+        nodeId: NodeId;
+        insertionPoint: InsertionPoint;
+    };
+    /**
+     * Ascends out of the current child list and updates the cursor to point to the parent
+     * node's next sibling.
+     */
+    ascend(): void;
+    /**
+     * Descends into the child list of the last node we inserted and updates the cursor to
+     * point to the node's first child.
+     */
+    descend(): void;
+}
+/** Returns an InsertionCursor which starts positioned at the root of the document. */
+export declare function createRootInsertionCursor(nodeIds: NodeIds): InsertionCursor;
+/**
+ * Returns an InsertionCursor which starts positioned in the child list of the given
+ * parent node. If a next sibling is provided, the cursor points to the position
+ * immediately before the next sibling; otherwise, the cursor points to the end of the
+ * child list.
+ */
+export declare function createChildInsertionCursor(parentId: NodeId, nextSiblingId: NodeId | undefined, nodeIds: NodeIds): InsertionCursor;

package/cjs/domain/record/serialization/insertionCursor.js

@@ -0,0 +1,55 @@
+//#region src/domain/record/serialization/insertionCursor.ts
+/** Returns an InsertionCursor which starts positioned at the root of the document. */
+function createRootInsertionCursor(nodeIds) {
+	return createInsertionCursor(void 0, void 0, nodeIds);
+}
+/**
+* Returns an InsertionCursor which starts positioned in the child list of the given
+* parent node. If a next sibling is provided, the cursor points to the position
+* immediately before the next sibling; otherwise, the cursor points to the end of the
+* child list.
+*/
+function createChildInsertionCursor(parentId, nextSiblingId, nodeIds) {
+	return createInsertionCursor(parentId, nextSiblingId, nodeIds);
+}
+function createInsertionCursor(parentId, nextSiblingId, nodeIds) {
+	let cursor = {
+		container: void 0,
+		parentId,
+		previousSiblingId: void 0,
+		nextSiblingId
+	};
+	const computeInsertionPoint = (nodeId) => {
+		if (cursor.previousSiblingId === nodeId - 1) return 0;
+		if (cursor.nextSiblingId !== void 0) return cursor.nextSiblingId - nodeId;
+		if (cursor.parentId !== void 0) return nodeId - cursor.parentId;
+		return null;
+	};
+	return {
+		advance(node) {
+			const nodeId = nodeIds.getOrInsert(node);
+			const insertionPoint = computeInsertionPoint(nodeId);
+			cursor.previousSiblingId = nodeId;
+			return {
+				nodeId,
+				insertionPoint
+			};
+		},
+		ascend() {
+			if (cursor.container) cursor = cursor.container;
+		},
+		descend() {
+			if (cursor.previousSiblingId !== void 0) cursor = {
+				container: cursor,
+				parentId: cursor.previousSiblingId,
+				previousSiblingId: void 0,
+				nextSiblingId: void 0
+			};
+		}
+	};
+}
+//#endregion
+exports.createChildInsertionCursor = createChildInsertionCursor;
+exports.createRootInsertionCursor = createRootInsertionCursor;
+
+//# sourceMappingURL=insertionCursor.js.map

package/cjs/domain/record/serialization/insertionCursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"insertionCursor.js","names":[],"sources":["../../../../src/domain/record/serialization/insertionCursor.ts"],"sourcesContent":["import type { InsertionPoint } from '../../../types'\nimport type { NodeId, NodeIds } from '../encoding'\n\n/**\n * InsertionCursor tracks the point at which the next node will be inserted during\n * Change-style DOM serialization.\n *\n * When a new node is added to the document, we use an InsertionPoint to encode its\n * position. There are often multiple equally-valid ways to express the same insertion\n * point; we generally want to favor encodings that use as few characters as possible (to\n * reduce uncompressed size) and that are as repetitive as possible (to reduce compressed\n * size). InsertionCursor's purpose is to heuristically pick an efficient encoding based\n * on the nodes we've recently serialized, while doing as little work as possible. The\n * results are not optimal, but should be close to it in most situations.\n *\n * At the beginning of the serialization process, use a factory function like\n * createRootInsertionCursor() to create a new cursor with an appropriate initial\n * position.\n *\n * When visiting a node, the expected usage pattern is as follows:\n * 1. Call advance() to get a node id and insertion point for the node.\n * 2. Serialize the node.\n * 3. If the node has no children, we're done; continue to the node's next\n * sibling and apply this algorithm again.\n * 4. Otherwise, call descend() to move the cursor into the node's child list.\n * 5. Recursively apply this algorithm.\n * 6. Call ascend() to move the cursor out of the node's child list. We're done;\n * continue to the node's next sibling and apply this algorithm again.\n */\nexport interface InsertionCursor {\n  /**\n   * Given the node id for a new node, returns the InsertionPoint for that node.\n   * Updates the cursor to point to the new node's next sibling.\n   */\n  advance(node: Node): { nodeId: NodeId; insertionPoint: InsertionPoint }\n\n  /**\n   * Ascends out of the current child list and updates the cursor to point to the parent\n   * node's next sibling.\n   */\n  ascend(): void\n\n  /**\n   * Descends into the child list of the last node we inserted and updates the cursor to\n   * point to the node's first child.\n   */\n  descend(): void\n}\n\n/** Returns an InsertionCursor which starts positioned at the root of the document. */\nexport function createRootInsertionCursor(nodeIds: NodeIds): InsertionCursor {\n  return createInsertionCursor(undefined, undefined, nodeIds)\n}\n\n/**\n * Returns an InsertionCursor which starts positioned in the child list of the given\n * parent node. If a next sibling is provided, the cursor points to the position\n * immediately before the next sibling; otherwise, the cursor points to the end of the\n * child list.\n */\nexport function createChildInsertionCursor(\n  parentId: NodeId,\n  nextSiblingId: NodeId | undefined,\n  nodeIds: NodeIds\n): InsertionCursor {\n  return createInsertionCursor(parentId, nextSiblingId, nodeIds)\n}\n\nfunction createInsertionCursor(\n  parentId: NodeId | undefined,\n  nextSiblingId: NodeId | undefined,\n  nodeIds: NodeIds\n): InsertionCursor {\n  interface ChildListCursor {\n    container: ChildListCursor | undefined\n    parentId: NodeId | undefined\n    previousSiblingId: NodeId | undefined\n    nextSiblingId: NodeId | undefined\n  }\n\n  let cursor: ChildListCursor = {\n    container: undefined,\n    parentId,\n    previousSiblingId: undefined,\n    nextSiblingId,\n  }\n\n  const computeInsertionPoint = (nodeId: NodeId): InsertionPoint => {\n    if (cursor.previousSiblingId === nodeId - 1) {\n      // Use an AppendAfterPreviousInsertionPoint. (i.e., 0)\n      return 0\n    }\n    if (cursor.nextSiblingId !== undefined) {\n      // Use an InsertBeforeInsertionPoint. We identify the next sibling using a\n      // negative integer indicating the difference between the new node's id and its next\n      // sibling's id.\n      return cursor.nextSiblingId - nodeId\n    }\n    if (cursor.parentId !== undefined) {\n      // Use an AppendChildInsertionPoint. We identify the parent node using a positive\n      // integer indicating the difference between the new node's id and its parent's id.\n      return nodeId - cursor.parentId\n    }\n    // There's no parent. Use a RootInsertionPoint. (i.e., null)\n    return null\n  }\n\n  return {\n    advance(node: Node): { nodeId: NodeId; insertionPoint: InsertionPoint } {\n      const nodeId = nodeIds.getOrInsert(node)\n      const insertionPoint = computeInsertionPoint(nodeId)\n      cursor.previousSiblingId = nodeId\n      return { nodeId, insertionPoint }\n    },\n    ascend(): void {\n      if (cursor.container) {\n        cursor = cursor.container\n      }\n    },\n    descend(): void {\n      if (cursor.previousSiblingId !== undefined) {\n        cursor = {\n          container: cursor,\n          parentId: cursor.previousSiblingId,\n          previousSiblingId: undefined,\n          nextSiblingId: undefined,\n        }\n      }\n    },\n  }\n}\n"],"mappings":";;AAkDA,SAAgB,0BAA0B,SAAmC;CAC3E,OAAO,sBAAsB,KAAA,GAAW,KAAA,GAAW,OAAO;AAC5D;;;;;;;AAQA,SAAgB,2BACd,UACA,eACA,SACiB;CACjB,OAAO,sBAAsB,UAAU,eAAe,OAAO;AAC/D;AAEA,SAAS,sBACP,UACA,eACA,SACiB;CAQjB,IAAI,SAA0B;EAC5B,WAAW,KAAA;EACX;EACA,mBAAmB,KAAA;EACnB;CACF;CAEA,MAAM,yBAAyB,WAAmC;EAChE,IAAI,OAAO,sBAAsB,SAAS,GAExC,OAAO;EAET,IAAI,OAAO,kBAAkB,KAAA,GAI3B,OAAO,OAAO,gBAAgB;EAEhC,IAAI,OAAO,aAAa,KAAA,GAGtB,OAAO,SAAS,OAAO;EAGzB,OAAO;CACT;CAEA,OAAO;EACL,QAAQ,MAAgE;GACtE,MAAM,SAAS,QAAQ,YAAY,IAAI;GACvC,MAAM,iBAAiB,sBAAsB,MAAM;GACnD,OAAO,oBAAoB;GAC3B,OAAO;IAAE;IAAQ;GAAe;EAClC;EACA,SAAe;GACb,IAAI,OAAO,WACT,SAAS,OAAO;EAEpB;EACA,UAAgB;GACd,IAAI,OAAO,sBAAsB,KAAA,GAC/B,SAAS;IACP,WAAW;IACX,UAAU,OAAO;IACjB,mBAAmB,KAAA;IACnB,eAAe,KAAA;GACjB;EAEJ;CACF;AACF"}

package/cjs/domain/record/serialization/serialization.types.d.ts

@@ -1,5 +1,3 @@
-import type { NodePrivacyLevel } from '@kubesense/kubesense-browser-rum-core';
-export type ParentNodePrivacyLevel = typeof NodePrivacyLevel.ALLOW | typeof NodePrivacyLevel.MASK | typeof NodePrivacyLevel.MASK_USER_INPUT | typeof NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED;
 /**
  * Virtual attributes. These attributes appear in the serialized attribute map of
  * elements, but they're not actually derived from the DOM; they're used to represent
@@ -22,7 +20,3 @@ export interface VirtualAttributes {
     /** For HIDDEN elements, the height of the element's bounding client rect. */
     rr_height?: string;
 }
-export interface SerializeOptions {
-    /** For HIDDEN elements, the height of the element's bounding client rect. */
-    rr_height?: string;
-}