chore: Apply eslint rules (or add ignores)

Author: Lms24

jest.setup.ts

@@ -1,8 +1,9 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { getCurrentHub } from '@sentry/core';
 import { Transport } from '@sentry/types';
 
-import { Session } from './src/session/Session';
 import { Replay } from './src';
+import { Session } from './src/session/Session';
 
 // @ts-ignore TS error, this is replaced in prod builds bc of rollup
 global.__SENTRY_REPLAY_VERSION__ = 'version:Test';
@@ -40,10 +41,8 @@ type SentReplayExpected = {
   events?: string | Uint8Array;
 };
 
-const toHaveSameSession = function (
-  received: jest.Mocked<Replay>,
-  expected: undefined | Session
-) {
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+const toHaveSameSession = function (received: jest.Mocked<Replay>, expected: undefined | Session) {
   const pass = this.equals(received.session?.id, expected?.id) as boolean;
 
   const options = {
@@ -54,13 +53,7 @@ const toHaveSameSession = function (
   return {
     pass,
     message: () =>
-      this.utils.matcherHint(
-        'toHaveSameSession',
-        undefined,
-        undefined,
-        options
-      ) +
-      '\n\n' +
+      `${this.utils.matcherHint('toHaveSameSession', undefined, undefined, options)}\n\n` +
       `Expected: ${pass ? 'not ' : ''}${this.utils.printExpected(expected)}\n` +
       `Received: ${this.utils.printReceived(received.session)}`,
   };
@@ -70,23 +63,17 @@ const toHaveSameSession = function (
  * Checks the last call to `fetch` and ensures a replay was uploaded by
  * checking the `fetch()` request's body.
  */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 const toHaveSentReplay = function (
   _received: jest.Mocked<Replay>,
-  expected?:
-    | SentReplayExpected
-    | { sample: SentReplayExpected; inverse: boolean }
+  expected?: SentReplayExpected | { sample: SentReplayExpected; inverse: boolean },
 ) {
-  const { calls } = (
-    getCurrentHub().getClient()?.getTransport()?.send as MockTransport
-  ).mock;
+  const { calls } = (getCurrentHub().getClient()?.getTransport()?.send as MockTransport).mock;
   const lastCall = calls[calls.length - 1]?.[0];
 
   const envelopeHeader = lastCall?.[0];
   const envelopeItems = lastCall?.[1] || [[], []];
-  const [
-    [replayEventHeader, replayEventPayload],
-    [recordingHeader, recordingPayload] = [],
-  ] = envelopeItems;
+  const [[replayEventHeader, replayEventPayload], [recordingHeader, recordingPayload] = []] = envelopeItems;
 
   // @ts-ignore recordingPayload is always a string in our tests
   const [recordingPayloadHeader, events] = recordingPayload?.split('\n') || [];
@@ -100,39 +87,28 @@ const toHaveSentReplay = function (
     replayEventPayload: replayEventPayload,
     // @ts-ignore Custom envelope
     recordingHeader: recordingHeader,
-    recordingPayloadHeader:
-      recordingPayloadHeader && JSON.parse(recordingPayloadHeader),
+    recordingPayloadHeader: recordingPayloadHeader && JSON.parse(recordingPayloadHeader),
     events,
   };
 
-  const isObjectContaining =
-    expected && 'sample' in expected && 'inverse' in expected;
+  const isObjectContaining = expected && 'sample' in expected && 'inverse' in expected;
   const expectedObj = isObjectContaining
     ? (expected as { sample: SentReplayExpected }).sample
     : (expected as SentReplayExpected);
 
   if (isObjectContaining) {
-    console.warn(
-      '`expect.objectContaining` is unnecessary when using the `toHaveSentReplay` matcher'
-    );
+    console.warn('`expect.objectContaining` is unnecessary when using the `toHaveSentReplay` matcher');
   }
 
   const results = expected
     ? Object.entries(actualObj)
         .map(([key, val]: [keyof SentReplayExpected, any]) => {
-          return [
-            !expectedObj?.[key] || this.equals(expectedObj[key], val),
-            key,
-            expectedObj?.[key],
-            val,
-          ];
+          return [!expectedObj?.[key] || this.equals(expectedObj[key], val), key, expectedObj?.[key], val];
         })
         .filter(([passed]) => !passed)
     : [];
 
-  const payloadPassed = Boolean(
-    lastCall && (!expected || results.length === 0)
-  );
+  const payloadPassed = Boolean(lastCall && (!expected || results.length === 0));
 
   const options = {
     isNot: this.isNot,
@@ -148,22 +124,13 @@ const toHaveSentReplay = function (
         ? allPass
           ? 'Expected Replay to not have been sent, but a request was attempted'
           : 'Expected Replay to have been sent, but a request was not attempted'
-        : this.utils.matcherHint(
-            'toHaveSentReplay',
-            undefined,
-            undefined,
-            options
-          ) +
-          '\n\n' +
-          results
+        : `${this.utils.matcherHint('toHaveSentReplay', undefined, undefined, options)}\n\n${results
             .map(
               ([, key, expected, actual]) =>
-                `Expected (key: ${key}): ${
-                  payloadPassed ? 'not ' : ''
-                }${this.utils.printExpected(expected)}\n` +
-                `Received (key: ${key}): ${this.utils.printReceived(actual)}`
+                `Expected (key: ${key}): ${payloadPassed ? 'not ' : ''}${this.utils.printExpected(expected)}\n` +
+                `Received (key: ${key}): ${this.utils.printReceived(actual)}`,
             )
-            .join('\n'),
+            .join('\n')}`,
   };
 };
 

src/coreHandlers/getBreadcrumbHandler.ts

@@ -1,8 +1,9 @@
 import { InstrumentationTypeBreadcrumb } from '../types';
-
 import { handleDom } from './handleDom';
 import { handleScope } from './handleScope';
 
+// TODO: Add return type
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/explicit-function-return-type
 export function getBreadcrumbHandler(type: InstrumentationTypeBreadcrumb) {
   if (type === 'scope') {
     return handleScope;

src/coreHandlers/getSpanHandler.ts

@@ -1,9 +1,10 @@
 import { InstrumentationTypeSpan } from '../types';
-
 import { handleFetch } from './handleFetch';
 import { handleHistory } from './handleHistory';
 import { handleXhr } from './handleXhr';
 
+// TODO: Add return type
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/explicit-function-return-type
 export function getSpanHandler(type: InstrumentationTypeSpan) {
   if (type === 'fetch') {
     return handleFetch;

src/coreHandlers/handleDom.ts

@@ -1,15 +1,17 @@
+import { Breadcrumb } from '@sentry/types';
 import { htmlTreeAsString } from '@sentry/utils';
 import { record } from 'rrweb';
 
 import { createBreadcrumb } from '../util/createBreadcrumb';
 
-export function handleDom(handlerData: any) {
+export function handleDom(handlerData: any): Breadcrumb | null {
   // Taken from https://github.com/getsentry/sentry-javascript/blob/master/packages/browser/src/integrations/breadcrumbs.ts#L112
   let target;
   let targetNode;
 
   // Accessing event.target can throw (see getsentry/raven-js#838, #768)
   try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     targetNode = (handlerData.event.target as Node) || (handlerData.event as unknown as Node);
     target = htmlTreeAsString(targetNode);
   } catch (e) {
@@ -21,6 +23,7 @@ export function handleDom(handlerData: any) {
   }
 
   return createBreadcrumb({
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     category: `ui.${handlerData.name}`,
     message: target,
     data: {

src/coreHandlers/handleScope.ts

@@ -4,8 +4,10 @@ import { createBreadcrumb } from '../util/createBreadcrumb';
 
 let _LAST_BREADCRUMB: null | Breadcrumb = null;
 
-export function handleScope(scope: Scope) {
-  //@ts-ignore using private val
+export function handleScope(scope: Scope): Breadcrumb | null {
+  // TODO: remove ignores here
+  // @ts-ignore using private val
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
   const newBreadcrumb = scope._breadcrumbs[scope._breadcrumbs.length - 1];
 
   // Listener can be called when breadcrumbs have not changed, so we store the
@@ -17,7 +19,9 @@ export function handleScope(scope: Scope) {
   _LAST_BREADCRUMB = newBreadcrumb;
 
   if (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     ['fetch', 'xhr', 'sentry.event', 'sentry.transaction'].includes(newBreadcrumb.category) ||
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     newBreadcrumb.category?.startsWith('ui.')
   ) {
     return null;

src/createPerformanceEntry.ts

@@ -1,8 +1,8 @@
 import { browserPerformanceTimeOrigin } from '@sentry/utils';
 import { record } from 'rrweb';
 
-import { isIngestHost } from './util/isIngestHost';
 import { AllPerformanceEntry } from './types';
+import { isIngestHost } from './util/isIngestHost';
 
 export interface ReplayPerformanceEntry {
   /**
@@ -45,24 +45,26 @@ const ENTRY_TYPES: Record<string, (entry: AllPerformanceEntry) => null | ReplayP
   ['largest-contentful-paint']: createLargestContentfulPaint,
 };
 
-export function createPerformanceEntries(entries: AllPerformanceEntry[]) {
+export function createPerformanceEntries(entries: AllPerformanceEntry[]): ReplayPerformanceEntry[] {
   return entries.map(createPerformanceEntry).filter(Boolean) as ReplayPerformanceEntry[];
 }
 
-function createPerformanceEntry(entry: AllPerformanceEntry) {
+function createPerformanceEntry(entry: AllPerformanceEntry): ReplayPerformanceEntry | null {
   if (ENTRY_TYPES[entry.entryType] === undefined) {
     return null;
   }
 
   return ENTRY_TYPES[entry.entryType](entry);
 }
 
-function getAbsoluteTime(time: number) {
+function getAbsoluteTime(time: number): number {
   // browserPerformanceTimeOrigin can be undefined if `performance` or
   // `performance.now` doesn't exist, but this is already checked by this integration
   return ((browserPerformanceTimeOrigin || window.performance.timeOrigin) + time) / 1000;
 }
 
+// TODO: type definition!
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function createPaintEntry(entry: PerformancePaintTiming) {
   const { duration, entryType, name, startTime } = entry;
 
@@ -75,6 +77,8 @@ function createPaintEntry(entry: PerformancePaintTiming) {
   };
 }
 
+// TODO: type definition!
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function createNavigationEntry(entry: PerformanceNavigationTiming) {
   // TODO: There looks to be some more interesting bits in here (domComplete, domContentLoaded)
   const { entryType, name, duration, domComplete, startTime, transferSize, type } = entry;
@@ -95,6 +99,9 @@ function createNavigationEntry(entry: PerformanceNavigationTiming) {
     },
   };
 }
+
+// TODO: type definition!
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function createResourceEntry(entry: PerformanceResourceTiming) {
   const { entryType, initiatorType, name, responseEnd, startTime, encodedBodySize, transferSize } = entry;
 
@@ -120,6 +127,8 @@ function createResourceEntry(entry: PerformanceResourceTiming) {
   };
 }
 
+// TODO: type definition!
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function createLargestContentfulPaint(entry: PerformanceEntry & { size: number; element: Node }) {
   const { duration, entryType, startTime, size } = entry;
 
@@ -139,6 +148,8 @@ function createLargestContentfulPaint(entry: PerformanceEntry & { size: number;
   };
 }
 
+// TODO: type definition!
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export function createMemoryEntry(memoryEntry: MemoryInfo) {
   const { jsHeapSizeLimit, totalJSHeapSize, usedJSHeapSize } = memoryEntry;
   // we don't want to use `getAbsoluteTime` because it adds the event time to the