@depup/datadog__browser-rum 6.31.0-depup.0

package/cjs/boot/lazyLoadRecorder.js

@@ -0,0 +1,56 @@
+"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.lazyLoadRecorder = lazyLoadRecorder;
+exports.importRecorder = importRecorder;
+const browser_core_1 = require("@datadog/browser-core");
+const scriptLoadingError_1 = require("../domain/scriptLoadingError");
+async function lazyLoadRecorder() {
+    try {
+        return await (0, browser_core_1.mockable)(importRecorder)();
+    }
+    catch (error) {
+        (0, scriptLoadingError_1.reportScriptLoadingError)({
+            error,
+            source: 'Recorder',
+            scriptType: 'module',
+        });
+    }
+}
+async function importRecorder() {
+    const module = await Promise.resolve().then(() => __importStar(require(/* webpackChunkName: "recorder" */ './startRecording')));
+    return module.startRecording;
+}
+//# sourceMappingURL=lazyLoadRecorder.js.map

package/cjs/boot/lazyLoadRecorder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazyLoadRecorder.js","sourceRoot":"","sources":["../../src/boot/lazyLoadRecorder.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,4CAUC;AAED,wCAGC;AAnBD,wDAAgD;AAChD,qEAAuE;AAGhE,KAAK,UAAU,gBAAgB;IACpC,IAAI,CAAC;QACH,OAAO,MAAM,IAAA,uBAAQ,EAAC,cAAc,CAAC,EAAE,CAAA;IACzC,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,IAAA,6CAAwB,EAAC;YACvB,KAAK;YACL,MAAM,EAAE,UAAU;YAClB,UAAU,EAAE,QAAQ;SACrB,CAAC,CAAA;IACJ,CAAC;AACH,CAAC;AAEM,KAAK,UAAU,cAAc;IAClC,MAAM,MAAM,GAAG,wDAAa,kCAAkC,CAAC,kBAAkB,GAAC,CAAA;IAClF,OAAO,MAAM,CAAC,cAAc,CAAA;AAC9B,CAAC"}

package/cjs/boot/postStartStrategy.d.ts

@@ -0,0 +1,33 @@
+import type { LifeCycle, RumConfiguration, RumSessionManager, StartRecordingOptions, ViewHistory } from '@datadog/browser-rum-core';
+import type { Telemetry, DeflateEncoder } from '@datadog/browser-core';
+import type { startRecording } from './startRecording';
+export type StartRecording = typeof startRecording;
+export declare const enum RecorderStatus {
+    Stopped = 0,
+    IntentToStart = 1,
+    Starting = 2,
+    Started = 3
+}
+export type RecorderInitEvent = {
+    type: 'start';
+    forced: boolean;
+} | {
+    type: 'document-ready';
+} | {
+    type: 'recorder-settled';
+} | {
+    type: 'aborted';
+} | {
+    type: 'deflate-encoder-load-failed';
+} | {
+    type: 'recorder-load-failed';
+} | {
+    type: 'succeeded';
+};
+export interface Strategy {
+    start: (options?: StartRecordingOptions) => void;
+    stop: () => void;
+    isRecording: () => boolean;
+    getSessionReplayLink: () => string | undefined;
+}
+export declare function createPostStartStrategy(configuration: RumConfiguration, lifeCycle: LifeCycle, sessionManager: RumSessionManager, viewHistory: ViewHistory, loadRecorder: () => Promise<StartRecording | undefined>, getOrCreateDeflateEncoder: () => DeflateEncoder | undefined, telemetry: Telemetry): Strategy;

package/cjs/boot/postStartStrategy.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPostStartStrategy = createPostStartStrategy;
+const browser_core_1 = require("@datadog/browser-core");
+const getSessionReplayLink_1 = require("../domain/getSessionReplayLink");
+const startRecorderInitTelemetry_1 = require("../domain/startRecorderInitTelemetry");
+function createPostStartStrategy(configuration, lifeCycle, sessionManager, viewHistory, loadRecorder, getOrCreateDeflateEncoder, telemetry) {
+    let status = 0 /* RecorderStatus.Stopped */;
+    let stopRecording;
+    lifeCycle.subscribe(9 /* LifeCycleEventType.SESSION_EXPIRED */, () => {
+        if (status === 2 /* RecorderStatus.Starting */ || status === 3 /* RecorderStatus.Started */) {
+            stop();
+            status = 1 /* RecorderStatus.IntentToStart */;
+        }
+    });
+    lifeCycle.subscribe(10 /* LifeCycleEventType.SESSION_RENEWED */, () => {
+        if (status === 1 /* RecorderStatus.IntentToStart */) {
+            start();
+        }
+    });
+    const observable = new browser_core_1.Observable();
+    (0, startRecorderInitTelemetry_1.startRecorderInitTelemetry)(telemetry, observable);
+    const doStart = async (forced) => {
+        observable.notify({ type: 'start', forced });
+        const [startRecordingImpl] = await Promise.all([
+            notifyWhenSettled(observable, { type: 'recorder-settled' }, loadRecorder()),
+            notifyWhenSettled(observable, { type: 'document-ready' }, (0, browser_core_1.asyncRunOnReadyState)(configuration, 'interactive')),
+        ]);
+        if (status !== 2 /* RecorderStatus.Starting */) {
+            observable.notify({ type: 'aborted' });
+            return;
+        }
+        if (!startRecordingImpl) {
+            status = 0 /* RecorderStatus.Stopped */;
+            observable.notify({ type: 'recorder-load-failed' });
+            return;
+        }
+        const deflateEncoder = getOrCreateDeflateEncoder();
+        if (!deflateEncoder) {
+            status = 0 /* RecorderStatus.Stopped */;
+            observable.notify({ type: 'deflate-encoder-load-failed' });
+            return;
+        }
+        ;
+        ({ stop: stopRecording } = startRecordingImpl(lifeCycle, configuration, sessionManager, viewHistory, deflateEncoder, telemetry));
+        status = 3 /* RecorderStatus.Started */;
+        observable.notify({ type: 'succeeded' });
+    };
+    function start(options) {
+        const session = sessionManager.findTrackedSession();
+        if (canStartRecording(session, options)) {
+            status = 1 /* RecorderStatus.IntentToStart */;
+            return;
+        }
+        if (isRecordingInProgress(status)) {
+            return;
+        }
+        status = 2 /* RecorderStatus.Starting */;
+        const forced = shouldForceReplay(session, options) || false;
+        // Intentionally not awaiting doStart() to keep it asynchronous
+        doStart(forced).catch(browser_core_1.monitorError);
+        if (forced) {
+            sessionManager.setForcedReplay();
+        }
+    }
+    function stop() {
+        if (status === 3 /* RecorderStatus.Started */) {
+            stopRecording === null || stopRecording === void 0 ? void 0 : stopRecording();
+        }
+        status = 0 /* RecorderStatus.Stopped */;
+    }
+    return {
+        start,
+        stop,
+        getSessionReplayLink() {
+            return (0, getSessionReplayLink_1.getSessionReplayLink)(configuration, sessionManager, viewHistory, status !== 0 /* RecorderStatus.Stopped */);
+        },
+        isRecording: () => status === 3 /* RecorderStatus.Started */,
+    };
+}
+function canStartRecording(session, options) {
+    return !session || (session.sessionReplay === 0 /* SessionReplayState.OFF */ && (!options || !options.force));
+}
+function isRecordingInProgress(status) {
+    return status === 2 /* RecorderStatus.Starting */ || status === 3 /* RecorderStatus.Started */;
+}
+function shouldForceReplay(session, options) {
+    return options && options.force && session.sessionReplay === 0 /* SessionReplayState.OFF */;
+}
+async function notifyWhenSettled(observable, event, promise) {
+    try {
+        return await promise;
+    }
+    finally {
+        observable.notify(event);
+    }
+}
+//# sourceMappingURL=postStartStrategy.js.map

package/cjs/boot/postStartStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postStartStrategy.js","sourceRoot":"","sources":["../../src/boot/postStartStrategy.ts"],"names":[],"mappings":"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"}

package/cjs/boot/preStartStrategy.d.ts

@@ -0,0 +1,6 @@
+import type { RumConfiguration } from '@datadog/browser-rum-core';
+import type { Strategy } from './postStartStrategy';
+export declare function createPreStartStrategy(): {
+    strategy: Strategy;
+    shouldStartImmediately: (configuration: RumConfiguration) => boolean;
+};

package/cjs/boot/preStartStrategy.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPreStartStrategy = createPreStartStrategy;
+const browser_core_1 = require("@datadog/browser-core");
+function createPreStartStrategy() {
+    let status = 0 /* PreStartRecorderStatus.None */;
+    return {
+        strategy: {
+            start() {
+                status = 1 /* PreStartRecorderStatus.HadManualStart */;
+            },
+            stop() {
+                status = 2 /* PreStartRecorderStatus.HadManualStop */;
+            },
+            isRecording: () => false,
+            getSessionReplayLink: browser_core_1.noop,
+        },
+        shouldStartImmediately(configuration) {
+            return (status === 1 /* PreStartRecorderStatus.HadManualStart */ ||
+                (status === 0 /* PreStartRecorderStatus.None */ && !configuration.startSessionReplayRecordingManually));
+        },
+    };
+}
+//# sourceMappingURL=preStartStrategy.js.map

package/cjs/boot/preStartStrategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preStartStrategy.js","sourceRoot":"","sources":["../../src/boot/preStartStrategy.ts"],"names":[],"mappings":";;AAUA,wDAuBC;AAjCD,wDAA4C;AAU5C,SAAgB,sBAAsB;IAIpC,IAAI,MAAM,sCAA8B,CAAA;IACxC,OAAO;QACL,QAAQ,EAAE;YACR,KAAK;gBACH,MAAM,gDAAwC,CAAA;YAChD,CAAC;YACD,IAAI;gBACF,MAAM,+CAAuC,CAAA;YAC/C,CAAC;YACD,WAAW,EAAE,GAAG,EAAE,CAAC,KAAK;YACxB,oBAAoB,EAAE,mBAAgC;SACvD;QACD,sBAAsB,CAAC,aAAa;YAClC,OAAO,CACL,MAAM,kDAA0C;gBAChD,CAAC,MAAM,wCAAgC,IAAI,CAAC,aAAa,CAAC,mCAAmC,CAAC,CAC/F,CAAA;QACH,CAAC;KACF,CAAA;AACH,CAAC"}

package/cjs/boot/profilerApi.d.ts

@@ -0,0 +1,2 @@
+import type { ProfilerApi } from '@datadog/browser-rum-core';
+export declare function makeProfilerApi(): ProfilerApi;

package/cjs/boot/profilerApi.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeProfilerApi = makeProfilerApi;
+const browser_rum_core_1 = require("@datadog/browser-rum-core");
+const browser_core_1 = require("@datadog/browser-core");
+const profilingSupported_1 = require("../domain/profiling/profilingSupported");
+const profilingContext_1 = require("../domain/profiling/profilingContext");
+const lazyLoadProfiler_1 = require("./lazyLoadProfiler");
+function makeProfilerApi() {
+    let profiler;
+    function onRumStart(lifeCycle, hooks, configuration, sessionManager, viewHistory, createEncoder) {
+        const session = sessionManager.findTrackedSession(); // Check if the session is tracked.
+        if (!session) {
+            // No session tracked, no profiling.
+            // Note: No Profiling context is set at this stage.
+            return;
+        }
+        // Sampling (sticky sampling based on session id)
+        if (!(0, browser_rum_core_1.isSampled)(session.id, configuration.profilingSampleRate)) {
+            // No sampling, no profiling.
+            // Note: No Profiling context is set at this stage.
+            return;
+        }
+        // Listen to events and add the profiling context to them.
+        const profilingContextManager = (0, profilingContext_1.startProfilingContext)(hooks);
+        // Browser support check
+        if (!(0, profilingSupported_1.isProfilingSupported)()) {
+            profilingContextManager.set({
+                status: 'error',
+                error_reason: 'not-supported-by-browser',
+            });
+            return;
+        }
+        (0, lazyLoadProfiler_1.lazyLoadProfiler)()
+            .then((createRumProfiler) => {
+            if (!createRumProfiler) {
+                profilingContextManager.set({ status: 'error', error_reason: 'failed-to-lazy-load' });
+                return;
+            }
+            profiler = createRumProfiler(configuration, lifeCycle, sessionManager, profilingContextManager, createEncoder, viewHistory, undefined);
+            profiler.start();
+        })
+            .catch(browser_core_1.monitorError);
+    }
+    return {
+        onRumStart,
+        stop: () => {
+            profiler === null || profiler === void 0 ? void 0 : profiler.stop();
+        },
+    };
+}
+//# sourceMappingURL=profilerApi.js.map

package/cjs/boot/profilerApi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"profilerApi.js","sourceRoot":"","sources":["../../src/boot/profilerApi.ts"],"names":[],"mappings":";;AAgBA,0CAiEC;AAxED,gEAAqD;AACrD,wDAAoD;AAEpD,+EAA6E;AAC7E,2EAA4E;AAC5E,yDAAqD;AAErD,SAAgB,eAAe;IAC7B,IAAI,QAAiC,CAAA;IAErC,SAAS,UAAU,CACjB,SAAoB,EACpB,KAAY,EACZ,aAA+B,EAC/B,cAAiC,EACjC,WAAwB,EACxB,aAA4D;QAE5D,MAAM,OAAO,GAAG,cAAc,CAAC,kBAAkB,EAAE,CAAA,CAAC,mCAAmC;QAEvF,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,oCAAoC;YACpC,mDAAmD;YACnD,OAAM;QACR,CAAC;QAED,iDAAiD;QACjD,IAAI,CAAC,IAAA,4BAAS,EAAC,OAAO,CAAC,EAAE,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAAE,CAAC;YAC9D,6BAA6B;YAC7B,mDAAmD;YACnD,OAAM;QACR,CAAC;QAED,0DAA0D;QAC1D,MAAM,uBAAuB,GAAG,IAAA,wCAAqB,EAAC,KAAK,CAAC,CAAA;QAE5D,wBAAwB;QACxB,IAAI,CAAC,IAAA,yCAAoB,GAAE,EAAE,CAAC;YAC5B,uBAAuB,CAAC,GAAG,CAAC;gBAC1B,MAAM,EAAE,OAAO;gBACf,YAAY,EAAE,0BAA0B;aACzC,CAAC,CAAA;YACF,OAAM;QACR,CAAC;QAED,IAAA,mCAAgB,GAAE;aACf,IAAI,CAAC,CAAC,iBAAiB,EAAE,EAAE;YAC1B,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,uBAAuB,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,qBAAqB,EAAE,CAAC,CAAA;gBACrF,OAAM;YACR,CAAC;YAED,QAAQ,GAAG,iBAAiB,CAC1B,aAAa,EACb,SAAS,EACT,cAAc,EACd,uBAAuB,EACvB,aAAa,EACb,WAAW,EACX,SAAS,CACV,CAAA;YACD,QAAQ,CAAC,KAAK,EAAE,CAAA;QAClB,CAAC,CAAC;aACD,KAAK,CAAC,2BAAY,CAAC,CAAA;IACxB,CAAC;IAED,OAAO;QACL,UAAU;QACV,IAAI,EAAE,GAAG,EAAE;YACT,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAE,IAAI,EAAE,CAAA;QAClB,CAAC;KACF,CAAA;AACH,CAAC"}

package/cjs/boot/recorderApi.d.ts

@@ -0,0 +1,3 @@
+import type { RecorderApi } from '@datadog/browser-rum-core';
+import type { StartRecording } from './postStartStrategy';
+export declare function makeRecorderApi(loadRecorder: () => Promise<StartRecording | undefined>): RecorderApi;

package/cjs/boot/recorderApi.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRecorderApi = makeRecorderApi;
+const browser_core_1 = require("@datadog/browser-core");
+const replayStats_1 = require("../domain/replayStats");
+const deflate_1 = require("../domain/deflate");
+const isBrowserSupported_1 = require("./isBrowserSupported");
+const postStartStrategy_1 = require("./postStartStrategy");
+const preStartStrategy_1 = require("./preStartStrategy");
+function makeRecorderApi(loadRecorder) {
+    if (((0, browser_core_1.canUseEventBridge)() && !(0, browser_core_1.bridgeSupports)("records" /* BridgeCapability.RECORDS */)) || !(0, isBrowserSupported_1.isBrowserSupported)()) {
+        return {
+            start: browser_core_1.noop,
+            stop: browser_core_1.noop,
+            getReplayStats: () => undefined,
+            onRumStart: browser_core_1.noop,
+            isRecording: () => false,
+            getSessionReplayLink: () => undefined,
+        };
+    }
+    // eslint-disable-next-line prefer-const
+    let { strategy, shouldStartImmediately } = (0, preStartStrategy_1.createPreStartStrategy)();
+    return {
+        start: (options) => strategy.start(options),
+        stop: () => strategy.stop(),
+        getSessionReplayLink: () => strategy.getSessionReplayLink(),
+        onRumStart,
+        isRecording: () => 
+        // The worker is started optimistically, meaning we could have started to record but its
+        // initialization fails a bit later. This could happen when:
+        // * the worker URL (blob or plain URL) is blocked by CSP in Firefox only (Chromium and Safari
+        // throw an exception when instantiating the worker, and IE doesn't care about CSP)
+        // * the browser fails to load the worker in case the workerUrl is used
+        // * an unexpected error occurs in the Worker before initialization, ex:
+        //   * a runtime exception collected by monitor()
+        //   * a syntax error notified by the browser via an error event
+        // * the worker is unresponsive for some reason and timeouts
+        //
+        // It is not expected to happen often. Nonetheless, the "replayable" status on RUM events is
+        // an important part of the Datadog App:
+        // * If we have a false positive (we set has_replay: true even if no replay data is present),
+        // we might display broken links to the Session Replay player.
+        // * If we have a false negative (we don't set has_replay: true even if replay data is
+        // available), it is less noticeable because no link will be displayed.
+        //
+        // Thus, it is better to have false negative, so let's make sure the worker is correctly
+        // initialized before advertizing that we are recording.
+        //
+        // In the future, when the compression worker will also be used for RUM data, this will be
+        // less important since no RUM event will be sent when the worker fails to initialize.
+        (0, deflate_1.getDeflateWorkerStatus)() === 3 /* DeflateWorkerStatus.Initialized */ && strategy.isRecording(),
+        getReplayStats: (viewId) => (0, deflate_1.getDeflateWorkerStatus)() === 3 /* DeflateWorkerStatus.Initialized */ ? (0, replayStats_1.getReplayStats)(viewId) : undefined,
+    };
+    function onRumStart(lifeCycle, configuration, sessionManager, viewHistory, worker, telemetry) {
+        let cachedDeflateEncoder;
+        function getOrCreateDeflateEncoder() {
+            if (!cachedDeflateEncoder) {
+                worker !== null && worker !== void 0 ? worker : (worker = (0, deflate_1.startDeflateWorker)(configuration, 'Datadog Session Replay', () => strategy.stop()));
+                if (worker) {
+                    cachedDeflateEncoder = (0, deflate_1.createDeflateEncoder)(configuration, worker, 1 /* DeflateEncoderStreamId.REPLAY */);
+                }
+            }
+            return cachedDeflateEncoder;
+        }
+        strategy = (0, postStartStrategy_1.createPostStartStrategy)(configuration, lifeCycle, sessionManager, viewHistory, loadRecorder, getOrCreateDeflateEncoder, telemetry);
+        if (shouldStartImmediately(configuration)) {
+            strategy.start();
+        }
+    }
+}
+//# sourceMappingURL=recorderApi.js.map

package/cjs/boot/recorderApi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recorderApi.js","sourceRoot":"","sources":["../../src/boot/recorderApi.ts"],"names":[],"mappings":";;AA4BA,0CAoFC;AA/GD,wDAM8B;AAS9B,uDAA4E;AAC5E,+CAK0B;AAC1B,6DAAyD;AAEzD,2DAA6D;AAC7D,yDAA2D;AAE3D,SAAgB,eAAe,CAAC,YAAuD;IACrF,IAAI,CAAC,IAAA,gCAAiB,GAAE,IAAI,CAAC,IAAA,6BAAc,2CAA0B,CAAC,IAAI,CAAC,IAAA,uCAAkB,GAAE,EAAE,CAAC;QAChG,OAAO;YACL,KAAK,EAAE,mBAAI;YACX,IAAI,EAAE,mBAAI;YACV,cAAc,EAAE,GAAG,EAAE,CAAC,SAAS;YAC/B,UAAU,EAAE,mBAAI;YAChB,WAAW,EAAE,GAAG,EAAE,CAAC,KAAK;YACxB,oBAAoB,EAAE,GAAG,EAAE,CAAC,SAAS;SACtC,CAAA;IACH,CAAC;IAED,wCAAwC;IACxC,IAAI,EAAE,QAAQ,EAAE,sBAAsB,EAAE,GAAG,IAAA,yCAAsB,GAAE,CAAA;IAEnE,OAAO;QACL,KAAK,EAAE,CAAC,OAA+B,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC;QACnE,IAAI,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE;QAC3B,oBAAoB,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,oBAAoB,EAAE;QAC3D,UAAU;QACV,WAAW,EAAE,GAAG,EAAE;QAChB,wFAAwF;QACxF,4DAA4D;QAC5D,8FAA8F;QAC9F,mFAAmF;QACnF,uEAAuE;QACvE,wEAAwE;QACxE,iDAAiD;QACjD,gEAAgE;QAChE,4DAA4D;QAC5D,EAAE;QACF,4FAA4F;QAC5F,wCAAwC;QACxC,6FAA6F;QAC7F,8DAA8D;QAC9D,sFAAsF;QACtF,uEAAuE;QACvE,EAAE;QACF,wFAAwF;QACxF,wDAAwD;QACxD,EAAE;QACF,0FAA0F;QAC1F,sFAAsF;QACtF,IAAA,gCAAsB,GAAE,4CAAoC,IAAI,QAAQ,CAAC,WAAW,EAAE;QAExF,cAAc,EAAE,CAAC,MAAM,EAAE,EAAE,CACzB,IAAA,gCAAsB,GAAE,4CAAoC,CAAC,CAAC,CAAC,IAAA,4BAAkB,EAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS;KACxG,CAAA;IAED,SAAS,UAAU,CACjB,SAAoB,EACpB,aAA+B,EAC/B,cAAiC,EACjC,WAAwB,EACxB,MAAiC,EACjC,SAAoB;QAEpB,IAAI,oBAAgD,CAAA;QAEpD,SAAS,yBAAyB;YAChC,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBAC1B,MAAM,aAAN,MAAM,cAAN,MAAM,IAAN,MAAM,GAAK,IAAA,4BAAkB,EAAC,aAAa,EAAE,wBAAwB,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,EAAA;gBAE7F,IAAI,MAAM,EAAE,CAAC;oBACX,oBAAoB,GAAG,IAAA,8BAAoB,EAAC,aAAa,EAAE,MAAM,wCAAgC,CAAA;gBACnG,CAAC;YACH,CAAC;YACD,OAAO,oBAAoB,CAAA;QAC7B,CAAC;QAED,QAAQ,GAAG,IAAA,2CAAuB,EAChC,aAAa,EACb,SAAS,EACT,cAAc,EACd,WAAW,EACX,YAAY,EACZ,yBAAyB,EACzB,SAAS,CACV,CAAA;QAED,IAAI,sBAAsB,CAAC,aAAa,CAAC,EAAE,CAAC;YAC1C,QAAQ,CAAC,KAAK,EAAE,CAAA;QAClB,CAAC;IACH,CAAC;AACH,CAAC"}

package/cjs/boot/startRecording.d.ts

@@ -0,0 +1,6 @@
+import type { HttpRequest, DeflateEncoder, Telemetry } from '@datadog/browser-core';
+import type { LifeCycle, ViewHistory, RumConfiguration, RumSessionManager } from '@datadog/browser-rum-core';
+import type { ReplayPayload } from '../domain/segmentCollection';
+export declare function startRecording(lifeCycle: LifeCycle, configuration: RumConfiguration, sessionManager: RumSessionManager, viewHistory: ViewHistory, encoder: DeflateEncoder, telemetry: Telemetry, httpRequest?: HttpRequest<ReplayPayload>): {
+    stop: () => void;
+};

package/cjs/boot/startRecording.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRecording = startRecording;
+const browser_core_1 = require("@datadog/browser-core");
+const record_1 = require("../domain/record");
+const segmentCollection_1 = require("../domain/segmentCollection");
+const startRecordBridge_1 = require("../domain/startRecordBridge");
+function startRecording(lifeCycle, configuration, sessionManager, viewHistory, encoder, telemetry, httpRequest) {
+    const cleanupTasks = [];
+    const reportError = (error) => {
+        lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error });
+        // monitor-until: forever, to keep an eye on the errors reported to customers
+        (0, browser_core_1.addTelemetryDebug)('Error reported to customer', { 'error.message': error.message });
+    };
+    const replayRequest = httpRequest || (0, browser_core_1.createHttpRequest)([configuration.sessionReplayEndpointBuilder], reportError, segmentCollection_1.SEGMENT_BYTES_LIMIT);
+    let addRecord;
+    let addStats;
+    if (!(0, browser_core_1.canUseEventBridge)()) {
+        const segmentCollection = (0, segmentCollection_1.startSegmentCollection)(lifeCycle, configuration, sessionManager, viewHistory, replayRequest, encoder);
+        addRecord = segmentCollection.addRecord;
+        addStats = segmentCollection.addStats;
+        cleanupTasks.push(segmentCollection.stop);
+        const segmentTelemetry = (0, segmentCollection_1.startSegmentTelemetry)(telemetry, replayRequest.observable);
+        cleanupTasks.push(segmentTelemetry.stop);
+    }
+    else {
+        ;
+        ({ addRecord } = (0, startRecordBridge_1.startRecordBridge)(viewHistory));
+        addStats = browser_core_1.noop;
+    }
+    const { stop: stopRecording } = (0, record_1.record)({
+        emitRecord: addRecord,
+        emitStats: addStats,
+        configuration,
+        lifeCycle,
+        viewHistory,
+    });
+    cleanupTasks.push(stopRecording);
+    return {
+        stop: () => {
+            cleanupTasks.forEach((task) => task());
+        },
+    };
+}
+//# sourceMappingURL=startRecording.js.map

package/cjs/boot/startRecording.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startRecording.js","sourceRoot":"","sources":["../../src/boot/startRecording.ts"],"names":[],"mappings":";;AAYA,wCAyDC;AApED,wDAAqG;AAKrG,6CAAyC;AAEzC,mEAAgH;AAEhH,mEAA+D;AAE/D,SAAgB,cAAc,CAC5B,SAAoB,EACpB,aAA+B,EAC/B,cAAiC,EACjC,WAAwB,EACxB,OAAuB,EACvB,SAAoB,EACpB,WAAwC;IAExC,MAAM,YAAY,GAAsB,EAAE,CAAA;IAE1C,MAAM,WAAW,GAAG,CAAC,KAAe,EAAE,EAAE;QACtC,SAAS,CAAC,MAAM,kDAAyC,EAAE,KAAK,EAAE,CAAC,CAAA;QACnE,6EAA6E;QAC7E,IAAA,gCAAiB,EAAC,4BAA4B,EAAE,EAAE,eAAe,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAA;IACrF,CAAC,CAAA;IAED,MAAM,aAAa,GACjB,WAAW,IAAI,IAAA,gCAAiB,EAAC,CAAC,aAAa,CAAC,4BAA4B,CAAC,EAAE,WAAW,EAAE,uCAAmB,CAAC,CAAA;IAElH,IAAI,SAA0C,CAAA;IAC9C,IAAI,QAA6C,CAAA;IAEjD,IAAI,CAAC,IAAA,gCAAiB,GAAE,EAAE,CAAC;QACzB,MAAM,iBAAiB,GAAG,IAAA,0CAAsB,EAC9C,SAAS,EACT,aAAa,EACb,cAAc,EACd,WAAW,EACX,aAAa,EACb,OAAO,CACR,CAAA;QACD,SAAS,GAAG,iBAAiB,CAAC,SAAS,CAAA;QACvC,QAAQ,GAAG,iBAAiB,CAAC,QAAQ,CAAA;QACrC,YAAY,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAA;QAEzC,MAAM,gBAAgB,GAAG,IAAA,yCAAqB,EAAC,SAAS,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;QACnF,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAA;IAC1C,CAAC;SAAM,CAAC;QACN,CAAC;QAAA,CAAC,EAAE,SAAS,EAAE,GAAG,IAAA,qCAAiB,EAAC,WAAW,CAAC,CAAC,CAAA;QACjD,QAAQ,GAAG,mBAAI,CAAA;IACjB,CAAC;IAED,MAAM,EAAE,IAAI,EAAE,aAAa,EAAE,GAAG,IAAA,eAAM,EAAC;QACrC,UAAU,EAAE,SAAS;QACrB,SAAS,EAAE,QAAQ;QACnB,aAAa;QACb,SAAS;QACT,WAAW;KACZ,CAAC,CAAA;IACF,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;IAEhC,OAAO;QACL,IAAI,EAAE,GAAG,EAAE;YACT,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,CAAA;QACxC,CAAC;KACF,CAAA;AACH,CAAC"}

package/cjs/domain/deflate/deflateEncoder.d.ts

@@ -0,0 +1,3 @@
+import type { DeflateEncoder, DeflateEncoderStreamId, DeflateWorker } from '@datadog/browser-core';
+import type { RumConfiguration } from '@datadog/browser-rum-core';
+export declare function createDeflateEncoder(configuration: RumConfiguration, worker: DeflateWorker, streamId: DeflateEncoderStreamId): DeflateEncoder;

package/cjs/domain/deflate/deflateEncoder.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeflateEncoder = createDeflateEncoder;
+const browser_core_1 = require("@datadog/browser-core");
+function createDeflateEncoder(configuration, worker, streamId) {
+    let rawBytesCount = 0;
+    let compressedData = [];
+    let compressedDataTrailer;
+    let isEmpty = true;
+    let nextWriteActionId = 0;
+    const pendingWriteActions = [];
+    const { stop: removeMessageListener } = (0, browser_core_1.addEventListener)(configuration, worker, 'message', ({ data: workerResponse }) => {
+        if (workerResponse.type !== 'wrote' || workerResponse.streamId !== streamId) {
+            return;
+        }
+        const nextPendingAction = pendingWriteActions[0];
+        if (nextPendingAction) {
+            if (nextPendingAction.id === workerResponse.id) {
+                pendingWriteActions.shift();
+                rawBytesCount += workerResponse.additionalBytesCount;
+                compressedData.push(workerResponse.result);
+                compressedDataTrailer = workerResponse.trailer;
+                if (nextPendingAction.writeCallback) {
+                    nextPendingAction.writeCallback(workerResponse.result.byteLength);
+                }
+                else if (nextPendingAction.finishCallback) {
+                    nextPendingAction.finishCallback();
+                }
+            }
+            else if (nextPendingAction.id < workerResponse.id) {
+                // Worker responses received out of order
+                removeMessageListener();
+            }
+        }
+    });
+    function consumeResult() {
+        const output = compressedData.length === 0 ? new Uint8Array(0) : (0, browser_core_1.concatBuffers)(compressedData.concat(compressedDataTrailer));
+        const result = {
+            rawBytesCount,
+            output,
+            outputBytesCount: output.byteLength,
+            encoding: 'deflate',
+        };
+        rawBytesCount = 0;
+        compressedData = [];
+        return result;
+    }
+    function sendResetIfNeeded() {
+        if (!isEmpty) {
+            worker.postMessage({
+                action: 'reset',
+                streamId,
+            });
+            isEmpty = true;
+        }
+    }
+    return {
+        isAsync: true,
+        get isEmpty() {
+            return isEmpty;
+        },
+        write(data, callback) {
+            worker.postMessage({
+                action: 'write',
+                id: nextWriteActionId,
+                data,
+                streamId,
+            });
+            pendingWriteActions.push({
+                id: nextWriteActionId,
+                writeCallback: callback,
+                data,
+            });
+            isEmpty = false;
+            nextWriteActionId += 1;
+        },
+        finish(callback) {
+            sendResetIfNeeded();
+            if (!pendingWriteActions.length) {
+                callback(consumeResult());
+            }
+            else {
+                // Make sure we do not call any write callback
+                pendingWriteActions.forEach((pendingWriteAction) => {
+                    delete pendingWriteAction.writeCallback;
+                });
+                // Wait for the last action to finish before calling the finish callback
+                pendingWriteActions[pendingWriteActions.length - 1].finishCallback = () => callback(consumeResult());
+            }
+        },
+        finishSync() {
+            sendResetIfNeeded();
+            const pendingData = pendingWriteActions.map((pendingWriteAction) => pendingWriteAction.data).join('');
+            // Ignore all pending write actions responses from the worker
+            pendingWriteActions.length = 0;
+            return { ...consumeResult(), pendingData };
+        },
+        estimateEncodedBytesCount(data) {
+            // This is a rough estimation of the data size once it'll be encoded by deflate. We observed
+            // that if it's the first chunk of data pushed to the stream, the ratio is lower (3-4), but
+            // after that the ratio is greater (10+). We chose 8 here, which (on average) seems to produce
+            // requests of the expected size.
+            return data.length / 8;
+        },
+        stop() {
+            removeMessageListener();
+        },
+    };
+}
+//# sourceMappingURL=deflateEncoder.js.map

package/cjs/domain/deflate/deflateEncoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deflateEncoder.js","sourceRoot":"","sources":["../../../src/domain/deflate/deflateEncoder.ts"],"names":[],"mappings":"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"}

package/cjs/domain/deflate/deflateWorker.d.ts

@@ -0,0 +1,29 @@
+import type { DeflateWorker } from '@datadog/browser-core';
+import type { RumConfiguration } from '@datadog/browser-rum-core';
+export declare const INITIALIZATION_TIME_OUT_DELAY: number;
+/**
+ * In order to be sure that the worker is correctly working, we need a round trip of
+ * initialization messages, making the creation asynchronous.
+ * These worker lifecycle states handle this case.
+ */
+export declare const enum DeflateWorkerStatus {
+    Nil = 0,
+    Loading = 1,
+    Error = 2,
+    Initialized = 3
+}
+export type CreateDeflateWorker = typeof createDeflateWorker;
+export declare function createDeflateWorker(configuration: RumConfiguration): DeflateWorker;
+export declare function startDeflateWorker(configuration: RumConfiguration, source: string, onInitializationFailure: () => void): DeflateWorker | undefined;
+export declare function resetDeflateWorkerState(): void;
+export declare function getDeflateWorkerStatus(): DeflateWorkerStatus;
+/**
+ * Starts the deflate worker and handle messages and errors
+ *
+ * The spec allow browsers to handle worker errors differently:
+ * - Chromium throws an exception
+ * - Firefox fires an error event
+ *
+ * more details: https://bugzilla.mozilla.org/show_bug.cgi?id=1736865#c2
+ */
+export declare function doStartDeflateWorker(configuration: RumConfiguration, source: string): void;