fix a bunch of any vs unknown types problems

Author: lobsterkatie

packages/core/src/baseclient.ts

@@ -405,16 +405,16 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
           ...(b.data && {
             data: normalize(b.data, depth, maxBreadth),
           }),
-        })),
+        })) as Event['breadcrumbs'],
       }),
       ...(event.user && {
-        user: normalize(event.user, depth, maxBreadth),
+        user: normalize(event.user, depth, maxBreadth) as Event['user'],
       }),
       ...(event.contexts && {
-        contexts: normalize(event.contexts, depth, maxBreadth),
+        contexts: normalize(event.contexts, depth, maxBreadth) as Event['contexts'],
       }),
       ...(event.extra && {
-        extra: normalize(event.extra, depth, maxBreadth),
+        extra: normalize(event.extra, depth, maxBreadth) as Event['extra'],
       }),
     };
     // event.contexts.trace stores information about a Transaction. Similarly,
@@ -425,8 +425,8 @@ export abstract class BaseClient<B extends Backend, O extends Options> implement
     // so this block overwrites the normalized event to add back the original
     // Transaction information prior to normalization.
     if (event.contexts && event.contexts.trace) {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-      normalized.contexts.trace = event.contexts.trace;
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      normalized.contexts!.trace = event.contexts.trace;
     }
 
     event.sdkProcessingMetadata = { ...event.sdkProcessingMetadata, baseClientNormalized: true };

packages/integrations/src/offline.ts

@@ -109,7 +109,7 @@ export class Offline implements Integration {
    * @param event an event
    */
   private async _cacheEvent(event: Event): Promise<Event> {
-    return this.offlineEventStore.setItem<Event>(uuid4(), normalize(event));
+    return this.offlineEventStore.setItem<Event>(uuid4(), normalize(event) as Event);
   }
 
   /**

packages/utils/src/normalize.ts

@@ -5,7 +5,6 @@ import { memoBuilder, MemoFunc } from './memo';
 import { convertToPlainObject } from './object';
 import { getFunctionName } from './stacktrace';
 
-type UnknownMaybeWithToJson = unknown & { toJSON?: () => string };
 type Prototype = { constructor: (...args: unknown[]) => unknown };
 
 /**
@@ -27,18 +26,18 @@ type Prototype = { constructor: (...args: unknown[]) => unknown };
  * object in the normallized output..
  * @returns A normalized version of the object, or `"**non-serializable**"` if any errors are thrown during normalization.
  */
-export function normalize(input: unknown, depth: number = +Infinity, maxProperties: number = +Infinity): any {
+export function normalize(input: unknown, depth: number = +Infinity, maxProperties: number = +Infinity): unknown {
   try {
     // since we're at the outermost level, there is no key
-    return visit('', input as UnknownMaybeWithToJson, depth, maxProperties);
+    return visit('', input, depth, maxProperties);
   } catch (err) {
     return { ERROR: `**non-serializable** (${err})` };
   }
 }
 
 /** JSDoc */
 export function normalizeToSize<T>(
-  object: { [key: string]: any },
+  object: { [key: string]: unknown },
   // Default Node.js REPL depth
   depth: number = 3,
   // 100kB, as 200kB is max payload size, so half sounds reasonable
@@ -68,7 +67,7 @@ export function visit(
   depth: number = +Infinity,
   maxProperties: number = +Infinity,
   memo: MemoFunc = memoBuilder(),
-): Primitive | unknown[] | { [key: string]: unknown } {
+): Primitive | { [key: string]: unknown } {
   const [memoize, unmemoize] = memo;
 
   // if the value has a `toJSON` method, bail and let it do the work
@@ -230,6 +229,6 @@ function utf8Length(value: string): number {
 }
 
 /** Calculates bytes size of input object */
-function jsonSize(value: any): number {
+function jsonSize(value: unknown): number {
   return utf8Length(JSON.stringify(value));
 }