@sentry/replay 7.93.0 → 7.94.1

package/esm/index.js

@@ -53,36 +53,6 @@ const MIN_REPLAY_DURATION_LIMIT = 15000;
 /** The max. length of a replay. */
 const MAX_REPLAY_DURATION = 3600000; // 60 minutes in ms;
 
-const CANVAS_QUALITY = {
-  low: {
-    sampling: {
-      canvas: 1,
-    },
-    dataURLOptions: {
-      type: 'image/webp',
-      quality: 0.25,
-    },
-  },
-  medium: {
-    sampling: {
-      canvas: 2,
-    },
-    dataURLOptions: {
-      type: 'image/webp',
-      quality: 0.4,
-    },
-  },
-  high: {
-    sampling: {
-      canvas: 4,
-    },
-    dataURLOptions: {
-      type: 'image/webp',
-      quality: 0.5,
-    },
-  },
-};
-
 function _nullishCoalesce$1(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }function _optionalChain$5(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var NodeType$1;
 (function (NodeType) {
     NodeType[NodeType["Document"] = 0] = "Document";
@@ -506,18 +476,23 @@ function createMatchPredicate(className, selector) {
         const el = node;
         if (el === null)
             return false;
-        if (className) {
-            if (typeof className === 'string') {
-                if (el.matches(`.${className}`))
+        try {
+            if (className) {
+                if (typeof className === 'string') {
+                    if (el.matches(`.${className}`))
+                        return true;
+                }
+                else if (elementClassMatchesRegex(el, className)) {
                     return true;
+                }
             }
-            else if (elementClassMatchesRegex(el, className)) {
+            if (selector && el.matches(selector))
                 return true;
-            }
+            return false;
+        }
+        catch (e2) {
+            return false;
         }
-        if (selector && el.matches(selector))
-            return true;
-        return false;
     };
 }
 function needMaskingText(node, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText) {
@@ -3412,6 +3387,8 @@ class CanvasManagerNoop {
     }
     unlock() {
     }
+    snapshot() {
+    }
 }
 
 class StylesheetManager {
@@ -3512,7 +3489,6 @@ function wrapEvent(e) {
     eWithTime.timestamp = nowTimestamp();
     return eWithTime;
 }
-let _wrappedEmit;
 let _takeFullSnapshot;
 const mirror = createMirror();
 function record(options = {}) {
@@ -3632,7 +3608,6 @@ function record(options = {}) {
             }
         }
     };
-    _wrappedEmit = wrappedEmit;
     const wrappedMutationEmit = (m) => {
         wrappedEmit(wrapEvent({
             type: EventType.IncrementalSnapshot,
@@ -3686,6 +3661,15 @@ function record(options = {}) {
     }
     const processedNodeManager = new ProcessedNodeManager();
     const canvasManager = _getCanvasManager(getCanvasManager, {
+        mirror,
+        win: window,
+        mutationCb: (p) => wrappedEmit(wrapEvent({
+            type: EventType.IncrementalSnapshot,
+            data: {
+                source: IncrementalSource.CanvasMutation,
+                ...p,
+            },
+        })),
         recordCanvas,
         blockClass,
         blockSelector,
@@ -3972,29 +3956,18 @@ function takeFullSnapshot(isCheckout) {
     }
     _takeFullSnapshot(isCheckout);
 }
-function wrappedEmit(e) {
-    if (!_wrappedEmit) {
-        return;
-    }
-    _wrappedEmit(e);
-}
 record.mirror = mirror;
 record.takeFullSnapshot = takeFullSnapshot;
 function _getCanvasManager(getCanvasManagerFn, options) {
-    return getCanvasManagerFn
-        ? getCanvasManagerFn({
-            ...options,
-            mirror,
-            win: window,
-            mutationCb: (p) => wrappedEmit(wrapEvent({
-                type: EventType.IncrementalSnapshot,
-                data: {
-                    source: IncrementalSource.CanvasMutation,
-                    ...p,
-                },
-            })),
-        })
-        : new CanvasManagerNoop();
+    try {
+        return getCanvasManagerFn
+            ? getCanvasManagerFn(options)
+            : new CanvasManagerNoop();
+    }
+    catch (e2) {
+        console.warn('Unable to initialize CanvasManager');
+        return new CanvasManagerNoop();
+    }
 }
 
 const ReplayEventTypeIncrementalSnapshot = 3;
@@ -7432,6 +7405,7 @@ function createOptionsEvent(replay) {
     data: {
       tag: 'options',
       payload: {
+        shouldRecordCanvas: replay.isRecordingCanvas(),
         sessionSampleRate: options.sessionSampleRate,
         errorSampleRate: options.errorSampleRate,
         useCompressionOption: options.useCompression,
@@ -7895,6 +7869,10 @@ class ReplayContainer  {
    * Function to stop recording
    */
 
+  /**
+   * Internal use for canvas recording options
+   */
+
    constructor({
     options,
     recordingOptions,
@@ -7967,6 +7945,13 @@ class ReplayContainer  {
     return this._isPaused;
   }
 
+  /**
+   * Determine if canvas recording is enabled
+   */
+   isRecordingCanvas() {
+    return Boolean(this._canvas);
+  }
+
   /** Get the replay integration options. */
    getOptions() {
     return this._options;
@@ -8087,7 +8072,8 @@ class ReplayContainer  {
    */
    startRecording() {
     try {
-      const canvas = this._options._experiments.canvas;
+      const canvasOptions = this._canvas;
+
       this._stopRecording = record({
         ...this._recordingOptions,
         // When running in error sampling mode, we need to overwrite `checkoutEveryNms`
@@ -8096,12 +8082,14 @@ class ReplayContainer  {
         ...(this.recordingMode === 'buffer' && { checkoutEveryNms: BUFFER_CHECKOUT_TIME }),
         emit: getHandleRecordingEmit(this),
         onMutation: this._onMutationHandler,
-        ...(canvas &&
-          canvas.manager && {
-            recordCanvas: true,
-            getCanvasManager: canvas.manager,
-            ...(CANVAS_QUALITY[canvas.quality || 'medium'] || CANVAS_QUALITY.medium),
-          }),
+        ...(canvasOptions
+          ? {
+              recordCanvas: canvasOptions.recordCanvas,
+              getCanvasManager: canvasOptions.getCanvasManager,
+              sampling: canvasOptions.sampling,
+              dataURLOptions: canvasOptions.dataURLOptions,
+            }
+          : {}),
       });
     } catch (err) {
       this._handleException(err);
@@ -9427,6 +9415,7 @@ Sentry.init({ replaysOnErrorSampleRate: ${errorSampleRate} })`,
 
     return this._replay.getSessionId();
   }
+
   /**
    * Initializes replay.
    */
@@ -9435,6 +9424,12 @@ Sentry.init({ replaysOnErrorSampleRate: ${errorSampleRate} })`,
       return;
     }
 
+    // We have to run this in _initialize, because this runs in setTimeout
+    // So when this runs all integrations have been added
+    // Before this, we cannot access integrations on the client,
+    // so we need to mutate the options here
+    this._maybeLoadFromReplayCanvasIntegration();
+
     this._replay.initializeSampling();
   }
 
@@ -9448,6 +9443,27 @@ Sentry.init({ replaysOnErrorSampleRate: ${errorSampleRate} })`,
       recordingOptions: this._recordingOptions,
     });
   }
+
+  /** Get canvas options from ReplayCanvas integration, if it is also added. */
+   _maybeLoadFromReplayCanvasIntegration() {
+    // To save bundle size, we skip checking for stuff here
+    // and instead just try-catch everything - as generally this should all be defined
+    /* eslint-disable @typescript-eslint/no-non-null-assertion */
+    try {
+      const client = getClient();
+      const canvasIntegration = client.getIntegrationByName('ReplayCanvas')
+
+;
+      if (!canvasIntegration) {
+        return;
+      }
+
+      this._replay['_canvas'] = canvasIntegration.getOptions();
+    } catch (e) {
+      // ignore errors here
+    }
+    /* eslint-enable @typescript-eslint/no-non-null-assertion */
+  }
 }Replay.__initStatic();
 
 /** Parse Replay-related options from SDK options */