ref: Refactor some any (#14477)

Refactoring some `as any` type casts we have to avoid this.

Author: mydea

biome.json

@@ -44,6 +44,9 @@
       "angular.json",
       "ember/instance-initializers/**",
       "ember/types.d.ts",
+      "solidstart/*.d.ts",
+      "solidstart/client/",
+      "solidstart/server/",
       ".output",
       ".vinxi"
     ]

packages/browser-utils/src/instrument/dom.ts

@@ -64,24 +64,21 @@ export function instrumentDOM(): void {
   // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still
   // guaranteed to fire at least once.)
   ['EventTarget', 'Node'].forEach((target: string) => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-    const proto = (WINDOW as any)[target] && (WINDOW as any)[target].prototype;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
+    const globalObject = WINDOW as unknown as Record<string, { prototype?: object }>;
+    const targetObj = globalObject[target];
+    const proto = targetObj && targetObj.prototype;
+
+    // eslint-disable-next-line no-prototype-builtins
     if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
       return;
     }
 
     fill(proto, 'addEventListener', function (originalAddEventListener: AddEventListener): AddEventListener {
-      return function (
-        this: Element,
-        type: string,
-        listener: EventListenerOrEventListenerObject,
-        options?: boolean | AddEventListenerOptions,
-      ): AddEventListener {
+      return function (this: InstrumentedElement, type, listener, options): AddEventListener {
         if (type === 'click' || type == 'keypress') {
           try {
-            const el = this as InstrumentedElement;
-            const handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});
+            const handlers = (this.__sentry_instrumentation_handlers__ =
+              this.__sentry_instrumentation_handlers__ || {});
             const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });
 
             if (!handlerForType.handler) {
@@ -105,16 +102,10 @@ export function instrumentDOM(): void {
       proto,
       'removeEventListener',
       function (originalRemoveEventListener: RemoveEventListener): RemoveEventListener {
-        return function (
-          this: Element,
-          type: string,
-          listener: EventListenerOrEventListenerObject,
-          options?: boolean | EventListenerOptions,
-        ): () => void {
+        return function (this: InstrumentedElement, type, listener, options): () => void {
           if (type === 'click' || type == 'keypress') {
             try {
-              const el = this as InstrumentedElement;
-              const handlers = el.__sentry_instrumentation_handlers__ || {};
+              const handlers = this.__sentry_instrumentation_handlers__ || {};
               const handlerForType = handlers[type];
 
               if (handlerForType) {
@@ -128,7 +119,7 @@ export function instrumentDOM(): void {
 
                 // If there are no longer any custom handlers of any type on this element, cleanup everything.
                 if (Object.keys(handlers).length === 0) {
-                  delete el.__sentry_instrumentation_handlers__;
+                  delete this.__sentry_instrumentation_handlers__;
                 }
               }
             } catch (e) {

packages/browser/src/integrations/reportingobserver.ts

@@ -46,6 +46,13 @@ interface ReportingObserverOptions {
   types?: ReportTypes[];
 }
 
+/** This is experimental and the types are not included with TypeScript, sadly. */
+interface ReportingObserverClass {
+  new (handler: (reports: Report[]) => void, options: { buffered?: boolean; types?: ReportTypes[] }): {
+    observe: () => void;
+  };
+}
+
 const SETUP_CLIENTS = new WeakMap<Client, boolean>();
 
 const _reportingObserverIntegration = ((options: ReportingObserverOptions = {}) => {
@@ -99,13 +106,14 @@ const _reportingObserverIntegration = ((options: ReportingObserverOptions = {})
         return;
       }
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-      const observer = new (WINDOW as any).ReportingObserver(handler, {
-        buffered: true,
-        types,
-      });
+      const observer = new (WINDOW as typeof WINDOW & { ReportingObserver: ReportingObserverClass }).ReportingObserver(
+        handler,
+        {
+          buffered: true,
+          types,
+        },
+      );
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       observer.observe();
     },
 

packages/cloudflare/src/handler.ts

@@ -40,8 +40,7 @@ export function withSentry<E extends ExportedHandler<any>>(
 ): E {
   setAsyncLocalStorageAsyncContextStrategy();
 
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-  if ('fetch' in handler && typeof handler.fetch === 'function' && !(handler.fetch as any).__SENTRY_INSTRUMENTED__) {
+  if ('fetch' in handler && typeof handler.fetch === 'function' && !isInstrumented(handler.fetch)) {
     handler.fetch = new Proxy(handler.fetch, {
       apply(target, thisArg, args: Parameters<ExportedHandlerFetchHandler<ExtractEnv<E>>>) {
         const [request, env, context] = args;
@@ -50,16 +49,10 @@ export function withSentry<E extends ExportedHandler<any>>(
       },
     });
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-    (handler.fetch as any).__SENTRY_INSTRUMENTED__ = true;
+    markAsInstrumented(handler.fetch);
   }
 
-  if (
-    'scheduled' in handler &&
-    typeof handler.scheduled === 'function' &&
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-    !(handler.scheduled as any).__SENTRY_INSTRUMENTED__
-  ) {
+  if ('scheduled' in handler && typeof handler.scheduled === 'function' && !isInstrumented(handler.scheduled)) {
     handler.scheduled = new Proxy(handler.scheduled, {
       apply(target, thisArg, args: Parameters<ExportedHandlerScheduledHandler<ExtractEnv<E>>>) {
         const [event, env, context] = args;
@@ -97,9 +90,28 @@ export function withSentry<E extends ExportedHandler<any>>(
       },
     });
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-    (handler.scheduled as any).__SENTRY_INSTRUMENTED__ = true;
+    markAsInstrumented(handler.scheduled);
   }
 
   return handler;
 }
+
+type SentryInstrumented<T> = T & {
+  __SENTRY_INSTRUMENTED__?: boolean;
+};
+
+function markAsInstrumented<T>(handler: T): void {
+  try {
+    (handler as SentryInstrumented<T>).__SENTRY_INSTRUMENTED__ = true;
+  } catch {
+    // ignore errors here
+  }
+}
+
+function isInstrumented<T>(handler: T): boolean | undefined {
+  try {
+    return (handler as SentryInstrumented<T>).__SENTRY_INSTRUMENTED__;
+  } catch {
+    return false;
+  }
+}

packages/core/src/metrics/aggregator.ts

@@ -20,9 +20,8 @@ export class MetricsAggregator implements MetricsAggregatorBase {
   // that we store in memory.
   private _bucketsTotalWeight;
 
-  // Cast to any so that it can use Node.js timeout
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly _interval: any;
+  // We adjust the type here to add the `unref()` part, as setInterval can technically return a number of a NodeJS.Timer.
+  private readonly _interval: ReturnType<typeof setInterval> & { unref?: () => void };
 
   // SDKs are required to shift the flush interval by random() * rollup_in_seconds.
   // That shift is determined once per startup to create jittering.
@@ -40,11 +39,8 @@ export class MetricsAggregator implements MetricsAggregatorBase {
     this._buckets = new Map();
     this._bucketsTotalWeight = 0;
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    this._interval = setInterval(() => this._flush(), DEFAULT_FLUSH_INTERVAL) as any;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    this._interval = setInterval(() => this._flush(), DEFAULT_FLUSH_INTERVAL);
     if (this._interval.unref) {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       this._interval.unref();
     }
 

packages/core/src/transports/base.ts

@@ -61,8 +61,7 @@ export function createTransport(
       return resolvedSyncPromise({});
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const filteredEnvelope: Envelope = createEnvelope(envelope[0], filteredEnvelopeItems as any);
+    const filteredEnvelope: Envelope = createEnvelope(envelope[0], filteredEnvelopeItems as (typeof envelope)[1]);
 
     // Creates client report for each item in an envelope
     const recordEnvelopeLoss = (reason: EventDropReason): void => {

packages/core/src/utils-hoist/isBrowser.ts

@@ -13,8 +13,6 @@ type ElectronProcess = { type?: string };
 
 // Electron renderers with nodeIntegration enabled are detected as Node.js so we specifically test for them
 function isElectronNodeRenderer(): boolean {
-  return (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-    (GLOBAL_OBJ as any).process !== undefined && ((GLOBAL_OBJ as any).process as ElectronProcess).type === 'renderer'
-  );
+  const process = (GLOBAL_OBJ as typeof GLOBAL_OBJ & { process?: ElectronProcess }).process;
+  return !!process && process.type === 'renderer';
 }

packages/core/src/utils-hoist/misc.ts

@@ -211,8 +211,7 @@ export function addContextToFrame(lines: string[], frame: StackFrame, linesOfCon
  * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)
  */
 export function checkOrSetAlreadyCaught(exception: unknown): boolean {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  if (exception && (exception as any).__sentry_captured__) {
+  if (isAlreadyCaptured(exception)) {
     return true;
   }
 
@@ -227,6 +226,12 @@ export function checkOrSetAlreadyCaught(exception: unknown): boolean {
   return false;
 }
 
+function isAlreadyCaptured(exception: unknown): boolean | void {
+  try {
+    return (exception as { __sentry_captured__?: boolean }).__sentry_captured__;
+  } catch {} // eslint-disable-line no-empty
+}
+
 /**
  * Checks whether the given input is already an array, and if it isn't, wraps it in one.
  *

packages/core/src/utils-hoist/object.ts

@@ -296,7 +296,8 @@ function isPojo(input: unknown): input is Record<string, unknown> {
 export function objectify(wat: unknown): typeof Object {
   let objectified;
   switch (true) {
-    case wat === undefined || wat === null:
+    // this will catch both undefined and null
+    case wat == undefined:
       objectified = new String(wat);
       break;
 

packages/google-cloud-serverless/src/gcpfunction/http.ts

@@ -27,8 +27,7 @@ export function wrapHttpFunction(fn: HttpFunction, wrapOptions: Partial<WrapperO
 
   // Functions emulator from firebase-tools has a hack-ish workaround that saves the actual function
   // passed to `onRequest(...)` and in fact runs it so we need to wrap it too.
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-  const emulatorFunc = (fn as any).__emulator_func as HttpFunction | undefined;
+  const emulatorFunc = (fn as HttpFunction & { __emulator_func?: HttpFunction }).__emulator_func;
   if (emulatorFunc) {
     overrides = { __emulator_func: proxyFunction(emulatorFunc, wrap) };
   }