fix lint and ts checks

Author: TMisiukiewicz

lib/OnyxSnapshotCache.ts

@@ -10,12 +10,12 @@ class OnyxSnapshotCache {
     /**
      * Snapshot cache for ultimate performance - separate cache per Onyx key
      */
-    private snapshotCache: Map<string, Map<string, any>>;
+    private snapshotCache: Map<string, Map<string, unknown>>;
 
     /**
      * Maps selector functions to unique IDs for cache key generation
      */
-    private selectorIdMap: Map<UseOnyxSelector<any, any>, string>;
+    private selectorIdMap: Map<UseOnyxSelector<OnyxKey, unknown>, string>;
 
     /**
      * Counter for generating incremental selector IDs
@@ -31,12 +31,13 @@ class OnyxSnapshotCache {
     /**
      * Generate unique ID for selector functions using incrementing numbers
      */
-    getSelectorId(selector: UseOnyxSelector<any, any>): string {
-        if (!this.selectorIdMap.has(selector)) {
+    getSelectorId<TKey extends OnyxKey, TReturnValue>(selector: UseOnyxSelector<TKey, TReturnValue>): string {
+        const typedSelector = selector as unknown as UseOnyxSelector<OnyxKey, unknown>;
+        if (!this.selectorIdMap.has(typedSelector)) {
             const id = `selector_${this.selectorIdCounter++}`;
-            this.selectorIdMap.set(selector, id);
+            this.selectorIdMap.set(typedSelector, id);
         }
-        return this.selectorIdMap.get(selector)!;
+        return this.selectorIdMap.get(typedSelector)!;
     }
 
     /**
@@ -54,15 +55,15 @@ class OnyxSnapshotCache {
     /**
      * Get cached snapshot result for a key and cache key combination
      */
-    getCachedResult(key: string, cacheKey: string): any {
+    getCachedResult<T>(key: string, cacheKey: string): T | undefined {
         const keyCache = this.snapshotCache.get(key);
-        return keyCache?.get(cacheKey);
+        return keyCache?.get(cacheKey) as T | undefined;
     }
 
     /**
      * Set cached snapshot result for a key and cache key combination
      */
-    setCachedResult(key: string, cacheKey: string, result: any): void {
+    setCachedResult<T>(key: string, cacheKey: string, result: T): void {
         if (!this.snapshotCache.has(key)) {
             this.snapshotCache.set(key, new Map());
         }

lib/useOnyx.ts

@@ -209,7 +209,7 @@ function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(
         // Don't use cache for first connection with initWithStoredValues: false
         // Also don't use cache during active data updates (when shouldGetCachedValueRef is true)
         if (!(isFirstConnectionRef.current && options?.initWithStoredValues === false) && !shouldGetCachedValueRef.current) {
-            const cachedResult = onyxSnapshotCache.getCachedResult(keyStr, cacheKey);
+            const cachedResult = onyxSnapshotCache.getCachedResult<UseOnyxResult<TReturnValue>>(keyStr, cacheKey);
             if (cachedResult !== undefined) {
                 resultRef.current = cachedResult;
                 return cachedResult;
@@ -222,7 +222,7 @@ function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(
         if (isFirstConnectionRef.current && options?.initWithStoredValues === false) {
             const result = resultRef.current;
             // Store result in snapshot cache
-            onyxSnapshotCache.setCachedResult(keyStr, cacheKey, result);
+            onyxSnapshotCache.setCachedResult<UseOnyxResult<TReturnValue>>(keyStr, cacheKey, result);
             return result;
         }
 
@@ -298,7 +298,7 @@ function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(
             }
         }
 
-        onyxSnapshotCache.setCachedResult(keyStr, cacheKey, resultRef.current);
+        onyxSnapshotCache.setCachedResult<UseOnyxResult<TReturnValue>>(keyStr, cacheKey, resultRef.current);
 
         return resultRef.current;
     }, [options?.initWithStoredValues, options?.allowStaleData, options?.canBeMissing, key, memoizedSelector]);