@myinterview/widget-react 1.1.23-beta-78ffddc → 1.1.23-binary-check-one

package/dist/esm/index.js

@@ -370,21 +370,85 @@ function getLocationHref() {
   }
 }
 
-/** An error emitted by Sentry SDKs and related utilities. */
-class SentryError extends Error {
-  /** Display name of this error instance. */
+/** Prefix for logging strings */
+const PREFIX = 'Sentry Logger ';
 
-   constructor( message, logLevel = 'warn') {
-    super(message);this.message = message;
-    this.name = new.target.prototype.constructor.name;
-    // This sets the prototype to be `Error`, not `SentryError`. It's unclear why we do this, but commenting this line
-    // out causes various (seemingly totally unrelated) playwright tests consistently time out. FYI, this makes
-    // instances of `SentryError` fail `obj instanceof SentryError` checks.
-    Object.setPrototypeOf(this, new.target.prototype);
-    this.logLevel = logLevel;
+const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;
+
+/**
+ * Temporarily disable sentry console instrumentations.
+ *
+ * @param callback The function to run against the original `console` messages
+ * @returns The results of the callback
+ */
+function consoleSandbox(callback) {
+  if (!('console' in GLOBAL_OBJ)) {
+    return callback();
+  }
+
+  const originalConsole = GLOBAL_OBJ.console ;
+  const wrappedLevels = {};
+
+  // Restore all wrapped console methods
+  CONSOLE_LEVELS.forEach(level => {
+    // TODO(v7): Remove this check as it's only needed for Node 6
+    const originalWrappedFunc =
+      originalConsole[level] && (originalConsole[level] ).__sentry_original__;
+    if (level in originalConsole && originalWrappedFunc) {
+      wrappedLevels[level] = originalConsole[level] ;
+      originalConsole[level] = originalWrappedFunc ;
+    }
+  });
+
+  try {
+    return callback();
+  } finally {
+    // Revert restoration to wrapped state
+    Object.keys(wrappedLevels).forEach(level => {
+      originalConsole[level] = wrappedLevels[level ];
+    });
   }
 }
 
+function makeLogger() {
+  let enabled = false;
+  const logger = {
+    enable: () => {
+      enabled = true;
+    },
+    disable: () => {
+      enabled = false;
+    },
+  };
+
+  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+    CONSOLE_LEVELS.forEach(name => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      logger[name] = (...args) => {
+        if (enabled) {
+          consoleSandbox(() => {
+            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);
+          });
+        }
+      };
+    });
+  } else {
+    CONSOLE_LEVELS.forEach(name => {
+      logger[name] = () => undefined;
+    });
+  }
+
+  return logger ;
+}
+
+// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
+let logger;
+if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
+  logger = getGlobalSingleton('logger', makeLogger);
+} else {
+  logger = makeLogger();
+}
+
 /** Regular expression used to parse a Dsn. */
 const DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
 
@@ -413,13 +477,16 @@ function dsnToString(dsn, withPassword = false) {
  * Parses a Dsn from a given string.
  *
  * @param str A Dsn as string
- * @returns Dsn as DsnComponents
+ * @returns Dsn as DsnComponents or undefined if @param str is not a valid DSN string
  */
 function dsnFromString(str) {
   const match = DSN_REGEX.exec(str);
 
   if (!match) {
-    throw new SentryError(`Invalid Sentry Dsn: ${str}`);
+    // This should be logged to the console
+    // eslint-disable-next-line no-console
+    console.error(`Invalid Sentry Dsn: ${str}`);
+    return undefined;
   }
 
   const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);
@@ -456,117 +523,67 @@ function dsnFromComponents(components) {
 
 function validateDsn(dsn) {
   if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
-    return;
+    return true;
   }
 
   const { port, projectId, protocol } = dsn;
 
   const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];
-  requiredComponents.forEach(component => {
+  const hasMissingRequiredComponent = requiredComponents.find(component => {
     if (!dsn[component]) {
-      throw new SentryError(`Invalid Sentry Dsn: ${component} missing`);
+      logger.error(`Invalid Sentry Dsn: ${component} missing`);
+      return true;
     }
+    return false;
   });
 
+  if (hasMissingRequiredComponent) {
+    return false;
+  }
+
   if (!projectId.match(/^\d+$/)) {
-    throw new SentryError(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);
+    logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);
+    return false;
   }
 
   if (!isValidProtocol(protocol)) {
-    throw new SentryError(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);
+    logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);
+    return false;
   }
 
   if (port && isNaN(parseInt(port, 10))) {
-    throw new SentryError(`Invalid Sentry Dsn: Invalid port ${port}`);
+    logger.error(`Invalid Sentry Dsn: Invalid port ${port}`);
+    return false;
   }
 
   return true;
 }
 
-/** The Sentry Dsn, identifying a Sentry instance and project. */
-function makeDsn(from) {
-  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);
-  validateDsn(components);
-  return components;
-}
-
-/** Prefix for logging strings */
-const PREFIX = 'Sentry Logger ';
-
-const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;
-
 /**
- * Temporarily disable sentry console instrumentations.
- *
- * @param callback The function to run against the original `console` messages
- * @returns The results of the callback
+ * Creates a valid Sentry Dsn object, identifying a Sentry instance and project.
+ * @returns a valid DsnComponents object or `undefined` if @param from is an invalid DSN source
  */
-function consoleSandbox(callback) {
-  if (!('console' in GLOBAL_OBJ)) {
-    return callback();
-  }
-
-  const originalConsole = GLOBAL_OBJ.console ;
-  const wrappedLevels = {};
-
-  // Restore all wrapped console methods
-  CONSOLE_LEVELS.forEach(level => {
-    // TODO(v7): Remove this check as it's only needed for Node 6
-    const originalWrappedFunc =
-      originalConsole[level] && (originalConsole[level] ).__sentry_original__;
-    if (level in originalConsole && originalWrappedFunc) {
-      wrappedLevels[level] = originalConsole[level] ;
-      originalConsole[level] = originalWrappedFunc ;
-    }
-  });
-
-  try {
-    return callback();
-  } finally {
-    // Revert restoration to wrapped state
-    Object.keys(wrappedLevels).forEach(level => {
-      originalConsole[level] = wrappedLevels[level ];
-    });
+function makeDsn(from) {
+  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);
+  if (!components || !validateDsn(components)) {
+    return undefined;
   }
+  return components;
 }
 
-function makeLogger() {
-  let enabled = false;
-  const logger = {
-    enable: () => {
-      enabled = true;
-    },
-    disable: () => {
-      enabled = false;
-    },
-  };
+/** An error emitted by Sentry SDKs and related utilities. */
+class SentryError extends Error {
+  /** Display name of this error instance. */
 
-  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
-    CONSOLE_LEVELS.forEach(name => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      logger[name] = (...args) => {
-        if (enabled) {
-          consoleSandbox(() => {
-            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);
-          });
-        }
-      };
-    });
-  } else {
-    CONSOLE_LEVELS.forEach(name => {
-      logger[name] = () => undefined;
-    });
+   constructor( message, logLevel = 'warn') {
+    super(message);this.message = message;
+    this.name = new.target.prototype.constructor.name;
+    // This sets the prototype to be `Error`, not `SentryError`. It's unclear why we do this, but commenting this line
+    // out causes various (seemingly totally unrelated) playwright tests consistently time out. FYI, this makes
+    // instances of `SentryError` fail `obj instanceof SentryError` checks.
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.logLevel = logLevel;
   }
-
-  return logger ;
-}
-
-// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
-let logger;
-if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {
-  logger = getGlobalSingleton('logger', makeLogger);
-} else {
-  logger = makeLogger();
 }
 
 /**
@@ -5066,16 +5083,20 @@ class BaseClient {
    */
    constructor(options) {BaseClient.prototype.__init.call(this);BaseClient.prototype.__init2.call(this);BaseClient.prototype.__init3.call(this);BaseClient.prototype.__init4.call(this);BaseClient.prototype.__init5.call(this);
     this._options = options;
+
     if (options.dsn) {
       this._dsn = makeDsn(options.dsn);
+    } else {
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('No DSN provided, client will not do anything.');
+    }
+
+    if (this._dsn) {
       const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options);
       this._transport = options.transport({
         recordDroppedEvent: this.recordDroppedEvent.bind(this),
         ...options.transportOptions,
         url,
       });
-    } else {
-      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('No DSN provided, client will not do anything.');
     }
   }
 
@@ -5794,7 +5815,7 @@ function getEventForEnvelopeItem(item, type) {
   return Array.isArray(item) ? (item )[1] : undefined;
 }
 
-const SDK_VERSION = '7.52.1';
+const SDK_VERSION = '7.53.0';
 
 let originalFunctionToString;
 
@@ -11546,6 +11567,23 @@ var NodeType;
     NodeType[NodeType["Comment"] = 5] = "Comment";
 })(NodeType || (NodeType = {}));
 
+/* eslint-disable @typescript-eslint/naming-convention */
+
+var EventType; (function (EventType) {
+  const DomContentLoaded = 0; EventType[EventType["DomContentLoaded"] = DomContentLoaded] = "DomContentLoaded";
+  const Load = 1; EventType[EventType["Load"] = Load] = "Load";
+  const FullSnapshot = 2; EventType[EventType["FullSnapshot"] = FullSnapshot] = "FullSnapshot";
+  const IncrementalSnapshot = 3; EventType[EventType["IncrementalSnapshot"] = IncrementalSnapshot] = "IncrementalSnapshot";
+  const Meta = 4; EventType[EventType["Meta"] = Meta] = "Meta";
+  const Custom = 5; EventType[EventType["Custom"] = Custom] = "Custom";
+  const Plugin = 6; EventType[EventType["Plugin"] = Plugin] = "Plugin";
+})(EventType || (EventType = {}));
+
+/**
+ * This is a partial copy of rrweb's eventWithTime type which only contains the properties
+ * we specifcally need in the SDK.
+ */
+
 /**
  * Converts a timestamp to ms, if it was in s, or keeps it as ms.
  */
@@ -11588,7 +11626,18 @@ async function addEvent(
       replay.eventBuffer.clear();
     }
 
-    return await replay.eventBuffer.addEvent(event);
+    const replayOptions = replay.getOptions();
+
+    const eventAfterPossibleCallback =
+      typeof replayOptions.beforeAddRecordingEvent === 'function' && event.type === EventType.Custom
+        ? replayOptions.beforeAddRecordingEvent(event)
+        : event;
+
+    if (!eventAfterPossibleCallback) {
+      return;
+    }
+
+    return await replay.eventBuffer.addEvent(eventAfterPossibleCallback);
   } catch (error) {
     (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(error);
     await replay.stop('addEvent');
@@ -14564,23 +14613,6 @@ function debounce(func, wait, options) {
   return debounced;
 }
 
-/* eslint-disable @typescript-eslint/naming-convention */
-
-var EventType; (function (EventType) {
-  const DomContentLoaded = 0; EventType[EventType["DomContentLoaded"] = DomContentLoaded] = "DomContentLoaded";
-  const Load = 1; EventType[EventType["Load"] = Load] = "Load";
-  const FullSnapshot = 2; EventType[EventType["FullSnapshot"] = FullSnapshot] = "FullSnapshot";
-  const IncrementalSnapshot = 3; EventType[EventType["IncrementalSnapshot"] = IncrementalSnapshot] = "IncrementalSnapshot";
-  const Meta = 4; EventType[EventType["Meta"] = Meta] = "Meta";
-  const Custom = 5; EventType[EventType["Custom"] = Custom] = "Custom";
-  const Plugin = 6; EventType[EventType["Plugin"] = Plugin] = "Plugin";
-})(EventType || (EventType = {}));
-
-/**
- * This is a partial copy of rrweb's eventWithTime type which only contains the properties
- * we specifcally need in the SDK.
- */
-
 /**
  * Handler for recording events.
  *
@@ -14654,6 +14686,30 @@ function getHandleRecordingEmit(replay) {
         }
       }
 
+      const options = replay.getOptions();
+
+      // TODO: We want this as an experiment so that we can test
+      // internally and create metrics before making this the default
+      if (options._experiments.delayFlushOnCheckout) {
+        // If the full snapshot is due to an initial load, we will not have
+        // a previous session ID. In this case, we want to buffer events
+        // for a set amount of time before flushing. This can help avoid
+        // capturing replays of users that immediately close the window.
+        setTimeout(() => replay.conditionalFlush(), options._experiments.delayFlushOnCheckout);
+
+        // Cancel any previously debounced flushes to ensure there are no [near]
+        // simultaneous flushes happening. The latter request should be
+        // insignificant in this case, so wait for additional user interaction to
+        // trigger a new flush.
+        //
+        // This can happen because there's no guarantee that a recording event
+        // happens first. e.g. a mouse click can happen and trigger a debounced
+        // flush before the checkout.
+        replay.cancelFlush();
+
+        return true;
+      }
+
       // Flush immediately so that we do not miss the first segment, otherwise
       // it can prevent loading on the UI. This will cause an increase in short
       // replays (e.g. opening and closing a tab quickly), but these can be
@@ -15419,7 +15475,17 @@ class ReplayContainer  {
   }
 
   /**
-   *
+   * Only flush if `this.recordingMode === 'session'`
+   */
+   conditionalFlush() {
+    if (this.recordingMode === 'buffer') {
+      return Promise.resolve();
+    }
+
+    return this.flushImmediate();
+  }
+
+  /**
    * Always flush via `_debouncedFlush` so that we do not have flushes triggered
    * from calling both `flush` and `_debouncedFlush`. Otherwise, there could be
    * cases of mulitple flushes happening closely together.
@@ -15430,6 +15496,13 @@ class ReplayContainer  {
     return this._debouncedFlush.flush() ;
   }
 
+  /**
+   * Cancels queued up flushes.
+   */
+   cancelFlush() {
+    this._debouncedFlush.cancel();
+  }
+
   /** Get the current sesion (=replay) ID */
    getSessionId() {
     return this.session && this.session.id;
@@ -15679,7 +15752,7 @@ class ReplayContainer  {
     // Send replay when the page/tab becomes hidden. There is no reason to send
     // replay if it becomes visible, since no actions we care about were done
     // while it was hidden
-    this._conditionalFlush();
+    void this.conditionalFlush();
   }
 
   /**
@@ -15763,17 +15836,6 @@ class ReplayContainer  {
     return Promise.all(createPerformanceSpans(this, createPerformanceEntries(entries)));
   }
 
-  /**
-   * Only flush if `this.recordingMode === 'session'`
-   */
-   _conditionalFlush() {
-    if (this.recordingMode === 'buffer') {
-      return;
-    }
-
-    void this.flushImmediate();
-  }
-
   /**
    * Clear _context
    */
@@ -16135,6 +16197,8 @@ class Replay  {
     ignore = [],
     maskFn,
 
+    beforeAddRecordingEvent,
+
     // eslint-disable-next-line deprecation/deprecation
     blockClass,
     // eslint-disable-next-line deprecation/deprecation
@@ -16192,6 +16256,7 @@ class Replay  {
       networkCaptureBodies,
       networkRequestHeaders: _getMergedNetworkHeaders(networkRequestHeaders),
       networkResponseHeaders: _getMergedNetworkHeaders(networkResponseHeaders),
+      beforeAddRecordingEvent,
 
       _experiments,
     };
@@ -30398,7 +30463,7 @@ const configGenerator = () => {
     let release;
     try {
         environment !== null && environment !== void 0 ? environment : (environment = "staging");
-        release !== null && release !== void 0 ? release : (release = "1.1.23");
+        release !== null && release !== void 0 ? release : (release = "1.1.23-binary-check-one");
     }
     catch (_a) {
         console.error('sentry configGenerator error');