react-native-onyx 3.0.52 → 3.0.54

package/dist/OnyxMerge/index.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const OnyxCache_1 = __importDefault(require("../OnyxCache"));
+const OnyxKeys_1 = __importDefault(require("../OnyxKeys"));
 const OnyxUtils_1 = __importDefault(require("../OnyxUtils"));
 const storage_1 = __importDefault(require("../storage"));
 const applyMerge = (key, existingValue, validChanges) => {
@@ -14,7 +15,7 @@ const applyMerge = (key, existingValue, validChanges) => {
     OnyxUtils_1.default.logKeyChanged(OnyxUtils_1.default.METHOD.MERGE, key, mergedValue, hasChanged);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
     const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
-    const shouldSkipStorageOperations = !hasChanged || OnyxUtils_1.default.isRamOnlyKey(key);
+    const shouldSkipStorageOperations = !hasChanged || OnyxKeys_1.default.isRamOnlyKey(key);
     // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
     // If the key is marked as RAM-only, it should not be saved nor updated in the storage.
     if (shouldSkipStorageOperations) {

package/dist/OnyxMerge/index.native.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const OnyxKeys_1 = __importDefault(require("../OnyxKeys"));
 const OnyxUtils_1 = __importDefault(require("../OnyxUtils"));
 const OnyxCache_1 = __importDefault(require("../OnyxCache"));
 const storage_1 = __importDefault(require("../storage"));
@@ -20,7 +21,7 @@ const applyMerge = (key, existingValue, validChanges) => {
     OnyxUtils_1.default.logKeyChanged(OnyxUtils_1.default.METHOD.MERGE, key, mergedValue, hasChanged);
     // This approach prioritizes fast UI changes without waiting for data to be stored in device storage.
     const updatePromise = OnyxUtils_1.default.broadcastUpdate(key, mergedValue, hasChanged);
-    const shouldSkipStorageOperations = !hasChanged || OnyxUtils_1.default.isRamOnlyKey(key);
+    const shouldSkipStorageOperations = !hasChanged || OnyxKeys_1.default.isRamOnlyKey(key);
     // If the value has not changed, calling Storage.setItem() would be redundant and a waste of performance, so return early instead.
     // If the key is marked as RAM-only, it should not be saved nor updated in the storage.
     if (shouldSkipStorageOperations) {

package/dist/OnyxSnapshotCache.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnyxSnapshotCache = void 0;
-const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
+const OnyxKeys_1 = __importDefault(require("./OnyxKeys"));
 /**
  * Manages snapshot caching for useOnyx hook performance optimization.
  * Handles selector function tracking and memoized getSnapshot results.
@@ -99,7 +99,7 @@ class OnyxSnapshotCache {
         // Always invalidate the exact key
         this.snapshotCache.delete(keyToInvalidate);
         // Check if the key is a collection member and invalidate the collection base key
-        const collectionBaseKey = OnyxUtils_1.default.getCollectionKey(keyToInvalidate);
+        const collectionBaseKey = OnyxKeys_1.default.getCollectionKey(keyToInvalidate);
         if (collectionBaseKey) {
             this.snapshotCache.delete(collectionBaseKey);
         }

package/dist/OnyxUtils.d.ts

@@ -1,6 +1,6 @@
 import type { ValueOf } from 'type-fest';
 import type Onyx from './Onyx';
-import type { CollectionKey, CollectionKeyBase, ConnectOptions, DeepRecord, KeyValueMapping, CallbackToStateMapping, MultiMergeReplaceNullPatches, OnyxCollection, OnyxEntry, OnyxInput, OnyxKey, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, Selector, MergeCollectionWithPatchesParams, SetCollectionParams, SetParams, OnyxMultiSetInput, RetriableOnyxOperation } from './types';
+import type { CollectionKeyBase, ConnectOptions, DeepRecord, KeyValueMapping, CallbackToStateMapping, MultiMergeReplaceNullPatches, OnyxCollection, OnyxEntry, OnyxInput, OnyxKey, OnyxMergeCollectionInput, OnyxUpdate, OnyxValue, Selector, MergeCollectionWithPatchesParams, SetCollectionParams, SetParams, OnyxMultiSetInput, RetriableOnyxOperation } from './types';
 import type { FastMergeResult } from './utils';
 import type { DeferredTask } from './createDeferredTask';
 import type { StorageKeyValuePair } from './storage/providers/types';
@@ -106,66 +106,6 @@ declare function storeKeyBySubscriptions(key: OnyxKey, subscriptionID: number):
 declare function deleteKeyBySubscriptions(subscriptionID: number): void;
 /** Returns current key names stored in persisted storage */
 declare function getAllKeys(): Promise<Set<OnyxKey>>;
-/**
- * Returns set of all registered collection keys
- */
-declare function getCollectionKeys(): Set<OnyxKey>;
-/**
- * Checks to see if the subscriber's supplied key
- * is associated with a collection of keys.
- */
-declare function isCollectionKey(key: OnyxKey): key is CollectionKeyBase;
-declare function isCollectionMemberKey<TCollectionKey extends CollectionKeyBase>(collectionKey: TCollectionKey, key: string): key is `${TCollectionKey}${string}`;
-/**
- * Checks if a given key is a collection member key (not just a collection key).
- * @param key - The key to check
- * @returns true if the key is a collection member, false otherwise
- */
-declare function isCollectionMember(key: OnyxKey): boolean;
-/**
- * Checks if a given key is a RAM-only key, RAM-only collection key, or a RAM-only collection member
- *
- * For example:
- *
- * For the following Onyx setup
- *
- * ramOnlyKeys: ["ramOnlyKey", "ramOnlyCollection_"]
- *
- * - `isRamOnlyKey("ramOnlyKey")` would return true
- * - `isRamOnlyKey("ramOnlyCollection_")` would return true
- * - `isRamOnlyKey("ramOnlyCollection_1")` would return true
- * - `isRamOnlyKey("someOtherKey")` would return false
- *
- * @param key - The key to check
- * @returns true if key is a RAM-only key, RAM-only collection key, or a RAM-only collection member
- */
-declare function isRamOnlyKey(key: OnyxKey): boolean;
-/**
- * Splits a collection member key into the collection key part and the ID part.
- * @param key - The collection member key to split.
- * @param collectionKey - The collection key of the `key` param that can be passed in advance to optimize the function.
- * @returns A tuple where the first element is the collection part and the second element is the ID part,
- * or throws an Error if the key is not a collection one.
- */
-declare function splitCollectionMemberKey<TKey extends CollectionKey, CollectionKeyType = TKey extends `${infer Prefix}_${string}` ? `${Prefix}_` : never>(key: TKey, collectionKey?: string): [CollectionKeyType, string];
-/**
- * Checks to see if a provided key is the exact configured key of our connected subscriber
- * or if the provided key is a collection member key (in case our configured key is a "collection key")
- */
-declare function isKeyMatch(configKey: OnyxKey, key: OnyxKey): boolean;
-/**
- * Extracts the collection identifier of a given collection member key.
- *
- * For example:
- * - `getCollectionKey("report_123")` would return "report_"
- * - `getCollectionKey("report_")` would return "report_"
- * - `getCollectionKey("report_-1_something")` would return "report_"
- * - `getCollectionKey("sharedNVP_user_-1_something")` would return "sharedNVP_user_"
- *
- * @param key - The collection key to process.
- * @returns The plain collection key or undefined if the key is not a collection one.
- */
-declare function getCollectionKey(key: CollectionKey): string | undefined;
 /**
  * Tries to get a value from the cache. If the value is not present in cache it will return the default value or undefined.
  * If the requested key is a collection, it will return an object with all the collection members.
@@ -357,18 +297,11 @@ declare const OnyxUtils: {
     sendActionToDevTools: typeof sendActionToDevTools;
     get: typeof get;
     getAllKeys: typeof getAllKeys;
-    getCollectionKeys: typeof getCollectionKeys;
-    isCollectionKey: typeof isCollectionKey;
-    isCollectionMemberKey: typeof isCollectionMemberKey;
-    isCollectionMember: typeof isCollectionMember;
-    splitCollectionMemberKey: typeof splitCollectionMemberKey;
-    isKeyMatch: typeof isKeyMatch;
     tryGetCachedValue: typeof tryGetCachedValue;
     getCachedCollection: typeof getCachedCollection;
     keysChanged: typeof keysChanged;
     keyChanged: typeof keyChanged;
     sendDataToConnection: typeof sendDataToConnection;
-    getCollectionKey: typeof getCollectionKey;
     getCollectionDataAndSendAsObject: typeof getCollectionDataAndSendAsObject;
     scheduleSubscriberUpdate: typeof scheduleSubscriberUpdate;
     scheduleNotifyCollectionSubscribers: typeof scheduleNotifyCollectionSubscribers;
@@ -404,7 +337,6 @@ declare const OnyxUtils: {
     setWithRetry: typeof setWithRetry;
     multiSetWithRetry: typeof multiSetWithRetry;
     setCollectionWithRetry: typeof setCollectionWithRetry;
-    isRamOnlyKey: typeof isRamOnlyKey;
 };
 export type { OnyxMethod };
 export default OnyxUtils;

package/dist/OnyxUtils.js

@@ -42,6 +42,7 @@ const underscore_1 = __importDefault(require("underscore"));
 const DevTools_1 = __importDefault(require("./DevTools"));
 const Logger = __importStar(require("./Logger"));
 const OnyxCache_1 = __importStar(require("./OnyxCache"));
+const OnyxKeys_1 = __importDefault(require("./OnyxKeys"));
 const Str = __importStar(require("./Str"));
 const storage_1 = __importDefault(require("./storage"));
 const utils_1 = __importDefault(require("./utils"));
@@ -78,8 +79,6 @@ let mergeQueuePromise = {};
 let nextMacrotaskPromise = null;
 // Holds a mapping of all the React components that want their state subscribed to a store key
 let callbackToStateMapping = {};
-// Keeps a copy of the values of the onyx collection keys as a map for faster lookups
-let onyxCollectionKeySet = new Set();
 // Holds a mapping of the connected key to the subscriptionID for faster lookups
 let onyxKeyToSubscriptionIDs = new Map();
 // Optional user-provided key value states set when Onyx initializes or clears
@@ -174,7 +173,7 @@ function initStoreValues(keys, initialKeyStates, evictableKeys) {
     // We need the value of the collection keys later for checking if a
     // key is a collection. We store it in a map for faster lookup.
     const collectionValues = Object.values((_a = keys.COLLECTION) !== null && _a !== void 0 ? _a : {});
-    onyxCollectionKeySet = collectionValues.reduce((acc, val) => {
+    const collectionKeySet = collectionValues.reduce((acc, val) => {
         acc.add(val);
         return acc;
     }, new Set());
@@ -184,7 +183,7 @@ function initStoreValues(keys, initialKeyStates, evictableKeys) {
     // Let Onyx know about which keys are safe to evict
     OnyxCache_1.default.setEvictionAllowList(evictableKeys);
     // Set collection keys in cache for optimized storage
-    OnyxCache_1.default.setCollectionKeys(onyxCollectionKeySet);
+    OnyxCache_1.default.setCollectionKeys(collectionKeySet);
     if (typeof keys.COLLECTION === 'object' && typeof keys.COLLECTION.SNAPSHOT === 'string') {
         snapshotKey = keys.COLLECTION.SNAPSHOT;
     }
@@ -213,7 +212,7 @@ function get(key) {
     // RAM-only keys should never read from storage (they may have stale persisted data
     // from before the key was migrated to RAM-only). Mark as nullish so future get() calls
     // short-circuit via hasCacheForKey and avoid re-running this branch.
-    if (isRamOnlyKey(key)) {
+    if (OnyxKeys_1.default.isRamOnlyKey(key)) {
         OnyxCache_1.default.addNullishStorageKey(key);
         return Promise.resolve(undefined);
     }
@@ -227,7 +226,7 @@ function get(key) {
         .then((val) => {
         if (skippableCollectionMemberIDs.size) {
             try {
-                const [, collectionMemberID] = splitCollectionMemberKey(key);
+                const [, collectionMemberID] = OnyxKeys_1.default.splitCollectionMemberKey(key);
                 if (skippableCollectionMemberIDs.has(collectionMemberID)) {
                     // The key is a skippable one, so we set the value to undefined.
                     // eslint-disable-next-line no-param-reassign
@@ -269,7 +268,7 @@ function multiGet(keys) {
     for (const key of keys) {
         // RAM-only keys should never read from storage as they may have stale persisted data
         // from before the key was migrated to RAM-only.
-        if (isRamOnlyKey(key)) {
+        if (OnyxKeys_1.default.isRamOnlyKey(key)) {
             if (OnyxCache_1.default.hasCacheForKey(key)) {
                 dataMap.set(key, OnyxCache_1.default.get(key));
             }
@@ -314,7 +313,7 @@ function multiGet(keys) {
         for (const [key, value] of values) {
             if (skippableCollectionMemberIDs.size) {
                 try {
-                    const [, collectionMemberID] = splitCollectionMemberKey(key);
+                    const [, collectionMemberID] = OnyxKeys_1.default.splitCollectionMemberKey(key);
                     if (skippableCollectionMemberIDs.has(collectionMemberID)) {
                         // The key is a skippable one, so we skip this iteration.
                         continue;
@@ -380,126 +379,20 @@ function getAllKeys() {
     const promise = storage_1.default.getAllKeys().then((keys) => {
         // Filter out RAM-only keys from storage results as they may be stale entries
         // from before the key was migrated to RAM-only.
-        const filteredKeys = keys.filter((key) => !isRamOnlyKey(key));
+        const filteredKeys = keys.filter((key) => !OnyxKeys_1.default.isRamOnlyKey(key));
         OnyxCache_1.default.setAllKeys(filteredKeys);
         // return the updated set of keys
         return OnyxCache_1.default.getAllKeys();
     });
     return OnyxCache_1.default.captureTask(OnyxCache_1.TASK.GET_ALL_KEYS, promise);
 }
-/**
- * Returns set of all registered collection keys
- */
-function getCollectionKeys() {
-    return onyxCollectionKeySet;
-}
-/**
- * Checks to see if the subscriber's supplied key
- * is associated with a collection of keys.
- */
-function isCollectionKey(key) {
-    return onyxCollectionKeySet.has(key);
-}
-function isCollectionMemberKey(collectionKey, key) {
-    return key.startsWith(collectionKey) && key.length > collectionKey.length;
-}
-/**
- * Checks if a given key is a collection member key (not just a collection key).
- * @param key - The key to check
- * @returns true if the key is a collection member, false otherwise
- */
-function isCollectionMember(key) {
-    const collectionKey = getCollectionKey(key);
-    // If the key is longer than the collection key, it's a collection member
-    return !!collectionKey && key.length > collectionKey.length;
-}
-/**
- * Checks if a given key is a RAM-only key, RAM-only collection key, or a RAM-only collection member
- *
- * For example:
- *
- * For the following Onyx setup
- *
- * ramOnlyKeys: ["ramOnlyKey", "ramOnlyCollection_"]
- *
- * - `isRamOnlyKey("ramOnlyKey")` would return true
- * - `isRamOnlyKey("ramOnlyCollection_")` would return true
- * - `isRamOnlyKey("ramOnlyCollection_1")` would return true
- * - `isRamOnlyKey("someOtherKey")` would return false
- *
- * @param key - The key to check
- * @returns true if key is a RAM-only key, RAM-only collection key, or a RAM-only collection member
- */
-function isRamOnlyKey(key) {
-    const collectionKey = getCollectionKey(key);
-    if (collectionKey) {
-        return OnyxCache_1.default.isRamOnlyKey(collectionKey);
-    }
-    return OnyxCache_1.default.isRamOnlyKey(key);
-}
-/**
- * Splits a collection member key into the collection key part and the ID part.
- * @param key - The collection member key to split.
- * @param collectionKey - The collection key of the `key` param that can be passed in advance to optimize the function.
- * @returns A tuple where the first element is the collection part and the second element is the ID part,
- * or throws an Error if the key is not a collection one.
- */
-function splitCollectionMemberKey(key, collectionKey) {
-    if (collectionKey && !isCollectionMemberKey(collectionKey, key)) {
-        throw new Error(`Invalid '${collectionKey}' collection key provided, it isn't compatible with '${key}' key.`);
-    }
-    if (!collectionKey) {
-        const resolvedKey = getCollectionKey(key);
-        if (!resolvedKey) {
-            throw new Error(`Invalid '${key}' key provided, only collection keys are allowed.`);
-        }
-        // eslint-disable-next-line no-param-reassign
-        collectionKey = resolvedKey;
-    }
-    return [collectionKey, key.slice(collectionKey.length)];
-}
-/**
- * Checks to see if a provided key is the exact configured key of our connected subscriber
- * or if the provided key is a collection member key (in case our configured key is a "collection key")
- */
-function isKeyMatch(configKey, key) {
-    return isCollectionKey(configKey) ? Str.startsWith(key, configKey) : configKey === key;
-}
-/**
- * Extracts the collection identifier of a given collection member key.
- *
- * For example:
- * - `getCollectionKey("report_123")` would return "report_"
- * - `getCollectionKey("report_")` would return "report_"
- * - `getCollectionKey("report_-1_something")` would return "report_"
- * - `getCollectionKey("sharedNVP_user_-1_something")` would return "sharedNVP_user_"
- *
- * @param key - The collection key to process.
- * @returns The plain collection key or undefined if the key is not a collection one.
- */
-function getCollectionKey(key) {
-    // Start by finding the position of the last underscore in the string
-    let lastUnderscoreIndex = key.lastIndexOf('_');
-    // Iterate backwards to find the longest key that ends with '_'
-    while (lastUnderscoreIndex > 0) {
-        const possibleKey = key.slice(0, lastUnderscoreIndex + 1);
-        // Check if the substring is a key in the Set
-        if (isCollectionKey(possibleKey)) {
-            // Return the matching key and the rest of the string
-            return possibleKey;
-        }
-        // Move to the next underscore to check smaller possible keys
-        lastUnderscoreIndex = key.lastIndexOf('_', lastUnderscoreIndex - 1);
-    }
-    return undefined;
-}
 /**
  * Tries to get a value from the cache. If the value is not present in cache it will return the default value or undefined.
  * If the requested key is a collection, it will return an object with all the collection members.
  */
 function tryGetCachedValue(key) {
     let val = OnyxCache_1.default.get(key);
-    if (isCollectionKey(key)) {
+    if (OnyxKeys_1.default.isCollectionKey(key)) {
         const collectionData = OnyxCache_1.default.getCollectionData(key);
         if (collectionData !== undefined) {
             val = collectionData;
@@ -543,7 +436,7 @@ function getCachedCollection(collectionKey, collectionMemberKeys) {
         // If we don't have collectionMemberKeys array then we have to check whether a key is a collection member key.
         // Because in that case the keys will be coming from `cache.getAllKeys()` and we need to filter out the keys that
         // are not part of the collection.
-        if (!collectionMemberKeys && !isCollectionMemberKey(collectionKey, key)) {
+        if (!collectionMemberKeys && !OnyxKeys_1.default.isCollectionMemberKey(collectionKey, key)) {
             continue;
         }
         const cachedValue = OnyxCache_1.default.get(key);
@@ -582,7 +475,7 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
         /**
          * e.g. Onyx.connect({key: `${ONYXKEYS.COLLECTION.REPORT}{reportID}`, callback: ...});
          */
-        const isSubscribedToCollectionMemberKey = isCollectionMemberKey(collectionKey, subscriber.key);
+        const isSubscribedToCollectionMemberKey = OnyxKeys_1.default.isCollectionMemberKey(collectionKey, subscriber.key);
         // Regular Onyx.connect() subscriber found.
         if (typeof subscriber.callback === 'function') {
             // If they are subscribed to the collection key and using waitForCollectionCallback then we'll
@@ -628,7 +521,7 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
     var _a, _b;
     // Add or remove this key from the recentlyAccessedKeys lists
     if (value !== null) {
-        OnyxCache_1.default.addLastAccessedKey(key, isCollectionKey(key));
+        OnyxCache_1.default.addLastAccessedKey(key, OnyxKeys_1.default.isCollectionKey(key));
     }
     else {
         OnyxCache_1.default.removeLastAccessedKey(key);
@@ -639,7 +532,7 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
     // do the same in keysChanged, because we only call that function when a collection key changes, and it doesn't happen that often.
     // For performance reason, we look for the given key and later if don't find it we look for the collection key, instead of checking if it is a collection key first.
     let stateMappingKeys = (_a = onyxKeyToSubscriptionIDs.get(key)) !== null && _a !== void 0 ? _a : [];
-    const collectionKey = getCollectionKey(key);
+    const collectionKey = OnyxKeys_1.default.getCollectionKey(key);
     if (collectionKey) {
         // Getting the collection key from the specific key because only collection keys were stored in the mapping.
         stateMappingKeys = [...stateMappingKeys, ...((_b = onyxKeyToSubscriptionIDs.get(collectionKey)) !== null && _b !== void 0 ? _b : [])];
@@ -650,7 +543,7 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
     const cachedCollections = {};
     for (const stateMappingKey of stateMappingKeys) {
         const subscriber = callbackToStateMapping[stateMappingKey];
-        if (!subscriber || !isKeyMatch(subscriber.key, key) || !canUpdateSubscriber(subscriber)) {
+        if (!subscriber || !OnyxKeys_1.default.isKeyMatch(subscriber.key, key) || !canUpdateSubscriber(subscriber)) {
             continue;
         }
         // Subscriber is a regular call to connect() and provided a callback
@@ -658,7 +551,7 @@ function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCo
             if (lastConnectionCallbackData.has(subscriber.subscriptionID) && lastConnectionCallbackData.get(subscriber.subscriptionID) === value) {
                 continue;
             }
-            if (isCollectionKey(subscriber.key) && subscriber.waitForCollectionCallback) {
+            if (OnyxKeys_1.default.isCollectionKey(subscriber.key) && subscriber.waitForCollectionCallback) {
                 // Skip individual key changes for collection callbacks during collection updates
                 // to prevent duplicate callbacks - the collection update will handle this properly
                 if (isProcessingCollectionUpdate) {
@@ -762,7 +655,7 @@ function scheduleNotifyCollectionSubscribers(key, value, previousValue) {
 function remove(key, isProcessingCollectionUpdate) {
     OnyxCache_1.default.drop(key);
     scheduleSubscriberUpdate(key, undefined, undefined, isProcessingCollectionUpdate);
-    if (isRamOnlyKey(key)) {
+    if (OnyxKeys_1.default.isRamOnlyKey(key)) {
         return Promise.resolve();
     }
     return storage_1.default.removeItem(key).then(() => undefined);
@@ -918,12 +811,12 @@ function initializeWithDefaultKeyStates() {
         for (const [key, value] of pairs) {
             // RAM-only keys should not be cached from storage as they may have stale persisted data
             // from before the key was migrated to RAM-only.
-            if (isRamOnlyKey(key)) {
+            if (OnyxKeys_1.default.isRamOnlyKey(key)) {
                 continue;
             }
             // Skip collection members that are marked as skippable
-            if (skippableCollectionMemberIDs.size && getCollectionKey(key)) {
-                const [, collectionMemberID] = splitCollectionMemberKey(key);
+            if (skippableCollectionMemberIDs.size && OnyxKeys_1.default.getCollectionKey(key)) {
+                const [, collectionMemberID] = OnyxKeys_1.default.splitCollectionMemberKey(key);
                 if (skippableCollectionMemberIDs.has(collectionMemberID)) {
                     continue;
                 }
@@ -981,7 +874,7 @@ function isValidNonEmptyCollectionForMerge(collection) {
 function doAllCollectionItemsBelongToSameParent(collectionKey, collectionKeys) {
     let hasCollectionKeyCheckFailed = false;
     for (const dataKey of collectionKeys) {
-        if (isKeyMatch(collectionKey, dataKey)) {
+        if (OnyxKeys_1.default.isKeyMatch(collectionKey, dataKey)) {
             continue;
         }
         if (process.env.NODE_ENV === 'development') {
@@ -1017,7 +910,7 @@ function subscribeToKey(connectOptions) {
         // Performance improvement
         // If the mapping is connected to an onyx key that is not a collection
         // we can skip the call to getAllKeys() and return an array with a single item
-        if (!!mapping.key && typeof mapping.key === 'string' && !isCollectionKey(mapping.key) && OnyxCache_1.default.getAllKeys().has(mapping.key)) {
+        if (!!mapping.key && typeof mapping.key === 'string' && !OnyxKeys_1.default.isCollectionKey(mapping.key) && OnyxCache_1.default.getAllKeys().has(mapping.key)) {
             return new Set([mapping.key]);
         }
         return getAllKeys();
@@ -1028,7 +921,7 @@ function subscribeToKey(connectOptions) {
         // subscribed to a "collection key" or a single key.
         const matchingKeys = [];
         // Performance optimization: For single key subscriptions, avoid O(n) iteration
-        if (!isCollectionKey(mapping.key)) {
+        if (!OnyxKeys_1.default.isCollectionKey(mapping.key)) {
             if (keys.has(mapping.key)) {
                 matchingKeys.push(mapping.key);
             }
@@ -1036,7 +929,7 @@ function subscribeToKey(connectOptions) {
         else {
             // Collection case - need to iterate through all keys to find matches (O(n))
             for (const key of keys) {
-                if (!isKeyMatch(mapping.key, key)) {
+                if (!OnyxKeys_1.default.isKeyMatch(mapping.key, key)) {
                     continue;
                 }
                 matchingKeys.push(key);
@@ -1049,7 +942,7 @@ function subscribeToKey(connectOptions) {
             if (mapping.key) {
                 OnyxCache_1.default.addNullishStorageKey(mapping.key);
             }
-            const matchedKey = isCollectionKey(mapping.key) && mapping.waitForCollectionCallback ? mapping.key : undefined;
+            const matchedKey = OnyxKeys_1.default.isCollectionKey(mapping.key) && mapping.waitForCollectionCallback ? mapping.key : undefined;
             // Here we cannot use batching because the nullish value is expected to be set immediately for default props
             // or they will be undefined.
             sendDataToConnection(mapping, null, matchedKey);
@@ -1059,7 +952,7 @@ function subscribeToKey(connectOptions) {
         // into an object and just make a single call. The latter behavior is enabled by providing a waitForCollectionCallback key
         // combined with a subscription to a collection key.
         if (typeof mapping.callback === 'function') {
-            if (isCollectionKey(mapping.key)) {
+            if (OnyxKeys_1.default.isCollectionKey(mapping.key)) {
                 if (mapping.waitForCollectionCallback) {
                     getCollectionDataAndSendAsObject(matchingKeys, mapping);
                     return;
@@ -1091,7 +984,7 @@ function unsubscribeFromKey(subscriptionID) {
     if (!callbackToStateMapping[subscriptionID]) {
         return;
     }
-    deleteKeyBySubscriptions(lastSubscriptionID);
+    deleteKeyBySubscriptions(subscriptionID);
     delete callbackToStateMapping[subscriptionID];
 }
 function updateSnapshots(data, mergeFn) {
@@ -1108,7 +1001,7 @@ function updateSnapshots(data, mergeFn) {
         let updatedData = {};
         for (const { key, value } of data) {
             // snapshots are normal keys so we want to skip update if they are written to Onyx
-            if (isCollectionMemberKey(snapshotCollectionKey, key)) {
+            if (OnyxKeys_1.default.isCollectionMemberKey(snapshotCollectionKey, key)) {
                 continue;
             }
             if (typeof snapshotEntryValue !== 'object' || !('data' in snapshotEntryValue)) {
@@ -1164,7 +1057,7 @@ function setWithRetry({ key, value, options }, retryAttempt) {
     }
     if (skippableCollectionMemberIDs.size) {
         try {
-            const [, collectionMemberID] = OnyxUtils.splitCollectionMemberKey(key);
+            const [, collectionMemberID] = OnyxKeys_1.default.splitCollectionMemberKey(key);
             if (skippableCollectionMemberIDs.has(collectionMemberID)) {
                 // The key is a skippable one, so we set the new value to null.
                 // eslint-disable-next-line no-param-reassign
@@ -1213,7 +1106,7 @@ function setWithRetry({ key, value, options }, retryAttempt) {
         return updatePromise;
     }
     // If a key is a RAM-only key or a member of RAM-only collection, we skip the step that modifies the storage
-    if (isRamOnlyKey(key)) {
+    if (OnyxKeys_1.default.isRamOnlyKey(key)) {
         OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET, key, valueWithoutNestedNullValues);
         return updatePromise;
     }
@@ -1237,7 +1130,7 @@ function multiSetWithRetry(data, retryAttempt) {
     if (skippableCollectionMemberIDs.size) {
         newData = Object.keys(newData).reduce((result, key) => {
             try {
-                const [, collectionMemberID] = OnyxUtils.splitCollectionMemberKey(key);
+                const [, collectionMemberID] = OnyxKeys_1.default.splitCollectionMemberKey(key);
                 // If the collection member key is a skippable one we set its value to null.
                 // eslint-disable-next-line no-param-reassign
                 result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? newData[key] : null;
@@ -1264,7 +1157,7 @@ function multiSetWithRetry(data, retryAttempt) {
     const keyValuePairsToStore = keyValuePairsToSet.filter((keyValuePair) => {
         const [key] = keyValuePair;
         // Filter out the RAM-only key value pairs, as they should not be saved to storage
-        return !isRamOnlyKey(key);
+        return !OnyxKeys_1.default.isRamOnlyKey(key);
     });
     return storage_1.default.multiSet(keyValuePairsToStore)
         .catch((error) => OnyxUtils.retryOperation(error, multiSetWithRetry, newData, retryAttempt))
@@ -1296,7 +1189,7 @@ function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
     if (skippableCollectionMemberIDs.size) {
         resultCollection = resultCollectionKeys.reduce((result, key) => {
             try {
-                const [, collectionMemberID] = OnyxUtils.splitCollectionMemberKey(key, collectionKey);
+                const [, collectionMemberID] = OnyxKeys_1.default.splitCollectionMemberKey(key, collectionKey);
                 // If the collection member key is a skippable one we set its value to null.
                 // eslint-disable-next-line no-param-reassign
                 result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? resultCollection[key] : null;
@@ -1327,7 +1220,7 @@ function setCollectionWithRetry({ collectionKey, collection }, retryAttempt) {
             OnyxCache_1.default.set(key, value);
         const updatePromise = OnyxUtils.scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
         // RAM-only keys are not supposed to be saved to storage
-        if (isRamOnlyKey(collectionKey)) {
+        if (OnyxKeys_1.default.isRamOnlyKey(collectionKey)) {
             OnyxUtils.sendActionToDevTools(OnyxUtils.METHOD.SET_COLLECTION, undefined, mutableCollection);
             return updatePromise;
         }
@@ -1366,7 +1259,7 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
     if (skippableCollectionMemberIDs.size) {
         resultCollection = resultCollectionKeys.reduce((result, key) => {
             try {
-                const [, collectionMemberID] = splitCollectionMemberKey(key, collectionKey);
+                const [, collectionMemberID] = OnyxKeys_1.default.splitCollectionMemberKey(key, collectionKey);
                 // If the collection member key is a skippable one we set its value to null.
                 // eslint-disable-next-line no-param-reassign
                 result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? resultCollection[key] : null;
@@ -1429,11 +1322,11 @@ function mergeCollectionWithPatches({ collectionKey, collection, mergeReplaceNul
         // New keys will be added via multiSet while existing keys will be updated using multiMerge
         // This is because setting a key that doesn't exist yet with multiMerge will throw errors
         // We can skip this step for RAM-only keys as they should never be saved to storage
-        if (!isRamOnlyKey(collectionKey) && keyValuePairsForExistingCollection.length > 0) {
+        if (!OnyxKeys_1.default.isRamOnlyKey(collectionKey) && keyValuePairsForExistingCollection.length > 0) {
             promises.push(storage_1.default.multiMerge(keyValuePairsForExistingCollection));
         }
         // We can skip this step for RAM-only keys as they should never be saved to storage
-        if (!isRamOnlyKey(collectionKey) && keyValuePairsForNewCollection.length > 0) {
+        if (!OnyxKeys_1.default.isRamOnlyKey(collectionKey) && keyValuePairsForNewCollection.length > 0) {
             promises.push(storage_1.default.multiSet(keyValuePairsForNewCollection));
         }
         // finalMergedCollection contains all the keys that were merged, without the keys of incompatible updates
@@ -1474,7 +1367,7 @@ function partialSetCollection({ collectionKey, collection }, retryAttempt) {
     if (skippableCollectionMemberIDs.size) {
         resultCollection = resultCollectionKeys.reduce((result, key) => {
             try {
-                const [, collectionMemberID] = splitCollectionMemberKey(key, collectionKey);
+                const [, collectionMemberID] = OnyxKeys_1.default.splitCollectionMemberKey(key, collectionKey);
                 // If the collection member key is a skippable one we set its value to null.
                 // eslint-disable-next-line no-param-reassign
                 result[key] = !skippableCollectionMemberIDs.has(collectionMemberID) ? resultCollection[key] : null;
@@ -1496,7 +1389,7 @@ function partialSetCollection({ collectionKey, collection }, retryAttempt) {
         for (const [key, value] of keyValuePairs)
             OnyxCache_1.default.set(key, value);
         const updatePromise = scheduleNotifyCollectionSubscribers(collectionKey, mutableCollection, previousCollection);
-        if (isRamOnlyKey(collectionKey)) {
+        if (OnyxKeys_1.default.isRamOnlyKey(collectionKey)) {
             sendActionToDevTools(METHOD.SET_COLLECTION, undefined, mutableCollection);
             return updatePromise;
         }
@@ -1535,18 +1428,11 @@ const OnyxUtils = {
     sendActionToDevTools,
     get,
     getAllKeys,
-    getCollectionKeys,
-    isCollectionKey,
-    isCollectionMemberKey,
-    isCollectionMember,
-    splitCollectionMemberKey,
-    isKeyMatch,
     tryGetCachedValue,
     getCachedCollection,
     keysChanged,
     keyChanged,
     sendDataToConnection,
-    getCollectionKey,
     getCollectionDataAndSendAsObject,
     scheduleSubscriberUpdate,
     scheduleNotifyCollectionSubscribers,
@@ -1582,7 +1468,6 @@ const OnyxUtils = {
     setWithRetry,
     multiSetWithRetry,
     setCollectionWithRetry,
-    isRamOnlyKey,
 };
 GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) => {
     if (!enablePerformanceMetrics) {
@@ -1596,8 +1481,6 @@ GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) =>
     // @ts-expect-error Reassign
     getAllKeys = (0, metrics_1.default)(getAllKeys, 'OnyxUtils.getAllKeys');
     // @ts-expect-error Reassign
-    getCollectionKeys = (0, metrics_1.default)(getCollectionKeys, 'OnyxUtils.getCollectionKeys');
-    // @ts-expect-error Reassign
     keysChanged = (0, metrics_1.default)(keysChanged, 'OnyxUtils.keysChanged');
     // @ts-expect-error Reassign
     keyChanged = (0, metrics_1.default)(keyChanged, 'OnyxUtils.keyChanged');

package/dist/useOnyx.js

@@ -41,6 +41,7 @@ const react_1 = require("react");
 const OnyxCache_1 = __importStar(require("./OnyxCache"));
 const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
+const OnyxKeys_1 = __importDefault(require("./OnyxKeys"));
 const GlobalSettings = __importStar(require("./GlobalSettings"));
 const usePrevious_1 = __importDefault(require("./usePrevious"));
 const metrics_1 = __importDefault(require("./metrics"));
@@ -251,7 +252,7 @@ function useOnyx(key, options, dependencies = []) {
                 onStoreChange();
             },
             initWithStoredValues: options === null || options === void 0 ? void 0 : options.initWithStoredValues,
-            waitForCollectionCallback: OnyxUtils_1.default.isCollectionKey(key),
+            waitForCollectionCallback: OnyxKeys_1.default.isCollectionKey(key),
             reuseConnection: options === null || options === void 0 ? void 0 : options.reuseConnection,
         });
         checkEvictableKey();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-onyx",
-  "version": "3.0.52",
+  "version": "3.0.54",
   "author": "Expensify, Inc.",
   "homepage": "https://expensify.com",
   "description": "State management for React Native",