add isSkippableKey to avoid recalculations

Author: waterim

lib/useOnyx.ts

@@ -163,6 +163,21 @@ function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(
 
     useEffect(() => () => onyxSnapshotCache.deregisterConsumer(key, cacheKey), [key, cacheKey]);
 
+    // Precompute whether this key is a skippable collection member so that getSnapshot()
+    // can use a cheap boolean check instead of calling splitCollectionMemberKey on every render.
+    const isSkippableKey = useMemo(() => {
+        const skippableIDs = OnyxUtils.getSkippableCollectionMemberIDs();
+        if (!skippableIDs.size) {
+            return false;
+        }
+        try {
+            const [, memberId] = OnyxUtils.splitCollectionMemberKey(key);
+            return skippableIDs.has(memberId);
+        } catch {
+            return false;
+        }
+    }, [key]);
+
     useEffect(() => {
         // These conditions will ensure we can only handle dynamic collection member keys from the same collection.
         if (options?.allowDynamicKey || previousKey === key) {
@@ -231,23 +246,16 @@ function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(
     }, [key, options?.canEvict]);
 
     const getSnapshot = useCallback(() => {
-        // Fast path: if subscribing to a skippable collection member id, return undefined as loaded immediately
-        if (isFirstConnectionRef.current) {
-            try {
-                const [, memberId] = OnyxUtils.splitCollectionMemberKey(key);
-                if (OnyxUtils.getSkippableCollectionMemberIDs().has(memberId)) {
-                    // Finalize initial state as loaded undefined and stop further first-connection flows
-                    if (resultRef.current[1].status !== 'loaded' || resultRef.current[0] !== undefined) {
-                        resultRef.current = [undefined, {status: 'loaded'}];
-                        onyxSnapshotCache.setCachedResult<UseOnyxResult<TReturnValue>>(key, cacheKey, resultRef.current);
-                    }
-                    isFirstConnectionRef.current = false;
-                    shouldGetCachedValueRef.current = false;
-                    return resultRef.current;
-                }
-            } catch (e) {
-                // Not a collection member, continue as usual
+        // Fast path: if subscribing to a skippable collection member id, return undefined as loaded immediately.
+        // The `isSkippableKey` flag is precomputed so we avoid calling splitCollectionMemberKey here.
+        if (isFirstConnectionRef.current && isSkippableKey) {
+            if (resultRef.current[1].status !== 'loaded' || resultRef.current[0] !== undefined) {
+                resultRef.current = [undefined, {status: 'loaded'}];
+                onyxSnapshotCache.setCachedResult<UseOnyxResult<TReturnValue>>(key, cacheKey, resultRef.current);
             }
+            isFirstConnectionRef.current = false;
+            shouldGetCachedValueRef.current = false;
+            return resultRef.current;
         }
         // Check if we have any cache for this Onyx key
         // Don't use cache for first connection with initWithStoredValues: false
@@ -349,7 +357,7 @@ function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(
         }
 
         return resultRef.current;
-    }, [options?.initWithStoredValues, options?.allowStaleData, options?.canBeMissing, key, memoizedSelector, cacheKey, previousKey]);
+    }, [options?.initWithStoredValues, options?.allowStaleData, options?.canBeMissing, key, memoizedSelector, cacheKey, previousKey, isSkippableKey]);
 
     const subscribe = useCallback(
         (onStoreChange: () => void) => {