react-native-onyx 3.0.53 → 3.0.55

package/README.md

@@ -351,59 +351,6 @@ const ReportActionsView = ({reportID, isActiveReport}) => {
 export default ReportActionsView;
 ```
 
-# Benchmarks
-
-Provide the `captureMetrics` boolean flag to `Onyx.init` to capture call statistics
-
-```js
-Onyx.init({
-    keys: ONYXKEYS,
-    evictableKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS],
-    captureMetrics: Config.BENCHMARK_ONYX,
-});
-```
-
-At any point you can get the collected statistics using `Onyx.getMetrics()`.
-This will return an object containing `totalTime`, `averageTime` and `summaries`.
-`summaries` is a collection of statistics for each method it contains data about:
-  - method name
-  - total, max, min, average times for this method calls
-  - calls - a list of individual calls with each having: start time; end time; call duration; call arguments
-    - start/end times are relative to application launch time - 0.00 being exactly at launch
-
-If you wish to reset the metrics and start over use `Onyx.resetMetrics()`
-
-Finally, there's a `Onyx.printMetrics()` method which prints human statistics information on the dev console. You can use this method during debugging. For example add an `Onyx.printMetrics()` line somewhere in code or call it through the dev console. It supports 3 popular formats *MD* - human friendly markdown, *CSV* and *JSON*. The default is MD if you want to print another format call `Onyx.printMetrics({ format: 'csv' })` or
-`Onyx.printMetrics({ format: 'json' })`.
-
-Sample output of `Onyx.printMetrics()`
-
-```
-### Onyx Benchmark
-  - Total: 1.5min
-  - Last call finished at: 12.55sec
-
-|     method      | total time spent |    max    |   min    |    avg    | time last call completed | calls made |
-|-----------------|-----------------:|----------:|---------:|----------:|-------------------------:|-----------:|
-| Onyx:getAllKeys |           1.2min |   2.16sec |  0.159ms | 782.230ms |                 12.55sec |         90 |
-| Onyx:merge      |          4.73sec |   2.00sec | 74.412ms | 591.642ms |                 10.24sec |          8 |
-| Onyx:set        |          3.90sec | 846.760ms | 43.663ms | 433.056ms |                  7.47sec |          9 |
-| Onyx:get        |          8.87sec |   2.00sec |  0.063ms |  61.998ms |                 10.24sec |        143 |
-
-
-|                           Onyx:set                            |
-|---------------------------------------------------------------|
-| start time | end time  | duration  |           args           |
-|-----------:|----------:|----------:|--------------------------|
-|  291.042ms | 553.079ms | 262.037ms | session, [object Object] |
-|  293.719ms | 553.316ms | 259.597ms | account, [object Object] |
-|  294.541ms | 553.651ms | 259.109ms | network, [object Object] |
-|  365.378ms | 554.246ms | 188.867ms | iou, [object Object]     |
-|    1.08sec |   2.20sec |   1.12sec | network, [object Object] |
-|    1.08sec |   2.20sec |   1.12sec | iou, [object Object]     |
-|    1.17sec |   2.20sec |   1.03sec | currentURL, /            |
-```
-
 # Debug mode
 
 It can be useful to log why Onyx is calling `setState()` on a particular React component so that we can understand which key changed, what changed about the value, and the connected component that ultimately rendered as a result. When used correctly this can help isolate problem areas and unnecessary renders in the code. To enable this feature, pass `debugSetState: true` to the config and grep JS console logs for `[Onyx-Debug]`.

package/dist/DevTools/RealDevTools.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const OnyxUtils_1 = __importDefault(require("../OnyxUtils"));
+const OnyxKeys_1 = __importDefault(require("../OnyxKeys"));
 const ERROR_LABEL = 'Onyx DevTools - Error: ';
 /**
  * Real implementation of DevTools that connects to Redux DevTools Extension
@@ -67,7 +67,7 @@ class RealDevTools {
     clearState(keysToPreserve = []) {
         const newState = Object.entries(this.state).reduce((obj, [key, value]) => {
             // eslint-disable-next-line no-param-reassign
-            obj[key] = keysToPreserve.some((preserveKey) => OnyxUtils_1.default.isKeyMatch(preserveKey, key)) ? value : this.defaultState[key];
+            obj[key] = keysToPreserve.some((preserveKey) => OnyxKeys_1.default.isKeyMatch(preserveKey, key)) ? value : this.defaultState[key];
             return obj;
         }, {});
         this.registerAction('CLEAR', undefined, newState);

package/dist/Onyx.d.ts

@@ -2,7 +2,7 @@ import * as Logger from './Logger';
 import type { CollectionKeyBase, ConnectOptions, InitOptions, OnyxKey, OnyxMergeCollectionInput, OnyxSetCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetInput, OnyxUpdate, SetOptions } from './types';
 import type { Connection } from './OnyxConnectionManager';
 /** Initialize the store with actions and listening for storage events */
-declare function init({ keys, initialKeyStates, evictableKeys, maxCachedKeysCount, shouldSyncMultipleInstances, enablePerformanceMetrics, enableDevTools, skippableCollectionMemberIDs, ramOnlyKeys, snapshotMergeKeys, }: InitOptions): void;
+declare function init({ keys, initialKeyStates, evictableKeys, maxCachedKeysCount, shouldSyncMultipleInstances, enableDevTools, skippableCollectionMemberIDs, ramOnlyKeys, snapshotMergeKeys, }: InitOptions): void;
 /**
  * Connects to an Onyx key given the options passed and listens to its changes.
  * This method will be deprecated soon. Please use `Onyx.connectWithoutView()` instead.

package/dist/Onyx.js

@@ -42,35 +42,30 @@ const storage_1 = __importDefault(require("./storage"));
 const utils_1 = __importDefault(require("./utils"));
 const DevTools_1 = __importStar(require("./DevTools"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
+const OnyxKeys_1 = __importDefault(require("./OnyxKeys"));
 const logMessages_1 = __importDefault(require("./logMessages"));
 const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager"));
-const GlobalSettings = __importStar(require("./GlobalSettings"));
-const metrics_1 = __importDefault(require("./metrics"));
 const OnyxMerge_1 = __importDefault(require("./OnyxMerge"));
 /** Initialize the store with actions and listening for storage events */
-function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = !!global.localStorage, enablePerformanceMetrics = false, enableDevTools = true, skippableCollectionMemberIDs = [], ramOnlyKeys = [], snapshotMergeKeys = [], }) {
+function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = !!global.localStorage, enableDevTools = true, skippableCollectionMemberIDs = [], ramOnlyKeys = [], snapshotMergeKeys = [], }) {
     var _a;
-    if (enablePerformanceMetrics) {
-        GlobalSettings.setPerformanceMetricsEnabled(true);
-        applyDecorators();
-    }
     (0, DevTools_1.initDevTools)(enableDevTools);
     storage_1.default.init();
     OnyxUtils_1.default.setSkippableCollectionMemberIDs(new Set(skippableCollectionMemberIDs));
     OnyxUtils_1.default.setSnapshotMergeKeys(new Set(snapshotMergeKeys));
-    OnyxCache_1.default.setRamOnlyKeys(new Set(ramOnlyKeys));
+    OnyxKeys_1.default.setRamOnlyKeys(new Set(ramOnlyKeys));
     if (shouldSyncMultipleInstances) {
         (_a = storage_1.default.keepInstancesSync) === null || _a === void 0 ? void 0 : _a.call(storage_1.default, (key, value) => {
             // RAM-only keys should never sync from storage as they may have stale persisted data
             // from before the key was migrated to RAM-only.
-            if (OnyxUtils_1.default.isRamOnlyKey(key)) {
+            if (OnyxKeys_1.default.isRamOnlyKey(key)) {
                 return;
             }
             OnyxCache_1.default.set(key, value);
             // Check if this is a collection member key to prevent duplicate callbacks
             // When a collection is updated, individual members sync separately to other tabs
             // Setting isProcessingCollectionUpdate=true prevents triggering collection callbacks for each individual update
-            const isKeyCollectionMember = OnyxUtils_1.default.isCollectionMember(key);
+            const isKeyCollectionMember = OnyxKeys_1.default.isCollectionMember(key);
             OnyxUtils_1.default.keyChanged(key, value, undefined, isKeyCollectionMember);
         });
     }
@@ -83,7 +78,7 @@ function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedK
     // eager cache loading populates the key index (cache.setAllKeys) inside initializeWithDefaultKeyStates,
     // and the evictable keys list depends on that index being populated.
     OnyxUtils_1.default.initializeWithDefaultKeyStates()
-        .then(() => OnyxCache_1.default.addEvictableKeysToRecentlyAccessedList(OnyxUtils_1.default.isCollectionKey, OnyxUtils_1.default.getAllKeys))
+        .then(() => OnyxCache_1.default.addEvictableKeysToRecentlyAccessedList(OnyxKeys_1.default.isCollectionKey, OnyxUtils_1.default.getAllKeys))
         .then(OnyxUtils_1.default.getDeferredInitTask().resolve);
 }
 /**
@@ -194,7 +189,7 @@ function merge(key, changes) {
         const skippableCollectionMemberIDs = OnyxUtils_1.default.getSkippableCollectionMemberIDs();
         if (skippableCollectionMemberIDs.size) {
             try {
-                const [, collectionMemberID] = OnyxUtils_1.default.splitCollectionMemberKey(key);
+                const [, collectionMemberID] = OnyxKeys_1.default.splitCollectionMemberKey(key);
                 if (skippableCollectionMemberIDs.has(collectionMemberID)) {
                     // The key is a skippable one, so we set the new changes to undefined.
                     // eslint-disable-next-line no-param-reassign
@@ -322,7 +317,7 @@ function clear(keysToPreserve = []) {
             //      to null would cause unknown behavior)
             //   2.1 However, if a default key was explicitly set to null, we need to reset it to the default value
             for (const key of allKeys) {
-                const isKeyToPreserve = keysToPreserve.some((preserveKey) => OnyxUtils_1.default.isKeyMatch(preserveKey, key));
+                const isKeyToPreserve = keysToPreserve.some((preserveKey) => OnyxKeys_1.default.isKeyMatch(preserveKey, key));
                 const isDefaultKey = key in defaultKeyStates;
                 // If the key is being removed or reset to default:
                 // 1. Update it in the cache
@@ -333,7 +328,7 @@ function clear(keysToPreserve = []) {
                     const newValue = (_a = defaultKeyStates[key]) !== null && _a !== void 0 ? _a : null;
                     if (newValue !== oldValue) {
                         OnyxCache_1.default.set(key, newValue);
-                        const collectionKey = OnyxUtils_1.default.getCollectionKey(key);
+                        const collectionKey = OnyxKeys_1.default.getCollectionKey(key);
                         if (collectionKey) {
                             if (!keyValuesToResetAsCollection[collectionKey]) {
                                 keyValuesToResetAsCollection[collectionKey] = { oldValues: {}, newValues: {} };
@@ -362,7 +357,7 @@ function clear(keysToPreserve = []) {
             }
             // Exclude RAM-only keys to prevent them from being saved to storage
             const defaultKeyValuePairs = Object.entries(Object.keys(defaultKeyStates)
-                .filter((key) => !keysToPreserve.some((preserveKey) => OnyxUtils_1.default.isKeyMatch(preserveKey, key)) && !OnyxUtils_1.default.isRamOnlyKey(key))
+                .filter((key) => !keysToPreserve.some((preserveKey) => OnyxKeys_1.default.isKeyMatch(preserveKey, key)) && !OnyxKeys_1.default.isRamOnlyKey(key))
                 .reduce((obj, key) => {
                 // eslint-disable-next-line no-param-reassign
                 obj[key] = defaultKeyStates[key];
@@ -459,8 +454,8 @@ function update(data) {
         // Group all the collection-related keys and update each collection in a single `mergeCollection` call.
         // This is needed to prevent multiple `mergeCollection` calls for the same collection and `merge` calls for the individual items of the said collection.
         // This way, we ensure there is no race condition in the queued updates of the same key.
-        for (const collectionKey of OnyxUtils_1.default.getCollectionKeys()) {
-            const collectionItemKeys = Object.keys(updateQueue).filter((key) => OnyxUtils_1.default.isKeyMatch(collectionKey, key));
+        for (const collectionKey of OnyxKeys_1.default.getCollectionKeys()) {
+            const collectionItemKeys = Object.keys(updateQueue).filter((key) => OnyxKeys_1.default.isKeyMatch(collectionKey, key));
             if (collectionItemKeys.length <= 1) {
                 // If there are no items of this collection in the updateQueue, we should skip it.
                 // If there is only one item, we should update it individually, therefore retain it in the updateQueue.
@@ -548,23 +543,4 @@ const Onyx = {
     init,
     registerLogger: Logger.registerLogger,
 };
-function applyDecorators() {
-    // We are reassigning the functions directly so that internal function calls are also decorated
-    // @ts-expect-error Reassign
-    connect = (0, metrics_1.default)(connect, 'Onyx.connect');
-    // @ts-expect-error Reassign
-    connectWithoutView = (0, metrics_1.default)(connectWithoutView, 'Onyx.connectWithoutView');
-    // @ts-expect-error Reassign
-    set = (0, metrics_1.default)(set, 'Onyx.set');
-    // @ts-expect-error Reassign
-    multiSet = (0, metrics_1.default)(multiSet, 'Onyx.multiSet');
-    // @ts-expect-error Reassign
-    merge = (0, metrics_1.default)(merge, 'Onyx.merge');
-    // @ts-expect-error Reassign
-    mergeCollection = (0, metrics_1.default)(mergeCollection, 'Onyx.mergeCollection');
-    // @ts-expect-error Reassign
-    update = (0, metrics_1.default)(update, 'Onyx.update');
-    // @ts-expect-error Reassign
-    clear = (0, metrics_1.default)(clear, 'Onyx.clear');
-}
 exports.default = Onyx;

package/dist/OnyxCache.d.ts

@@ -34,10 +34,6 @@ declare class OnyxCache {
     private evictionBlocklist;
     /** List of keys that have been directly subscribed to or recently modified from least to most recent */
     private recentlyAccessedKeys;
-    /** Set of collection keys for fast lookup */
-    private collectionKeys;
-    /** Set of RAM-only keys for fast lookup */
-    private ramOnlyKeys;
     constructor();
     /** Get all the storage keys */
     getAllKeys(): Set<OnyxKey>;
@@ -122,12 +118,6 @@ declare class OnyxCache {
      * @param testKey - Key to check
      */
     isEvictableKey(testKey: OnyxKey): boolean;
-    /**
-     * Check if a given key matches a pattern key
-     * @param configKey - Pattern that may contain a wildcard
-     * @param key - Key to test against the pattern
-     */
-    private isKeyMatch;
     /**
      * Remove a key from the recently accessed key list.
      */
@@ -155,26 +145,10 @@ declare class OnyxCache {
      * Set the collection keys for optimized storage
      */
     setCollectionKeys(collectionKeys: Set<OnyxKey>): void;
-    /**
-     * Check if a key is a collection key
-     */
-    isCollectionKey(key: OnyxKey): boolean;
-    /**
-     * Get the collection key for a given member key
-     */
-    getCollectionKey(key: OnyxKey): OnyxKey | undefined;
     /**
      * Get all data for a collection key
      */
     getCollectionData(collectionKey: OnyxKey): Record<OnyxKey, OnyxValue<OnyxKey>> | undefined;
-    /**
-     * Set the RAM-only keys for optimized storage
-     */
-    setRamOnlyKeys(ramOnlyKeys: Set<OnyxKey>): void;
-    /**
-     * Check if a key is a RAM-only key
-     */
-    isRamOnlyKey(key: OnyxKey): boolean;
 }
 declare const instance: OnyxCache;
 export default instance;

package/dist/OnyxCache.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -40,7 +7,7 @@ exports.TASK = void 0;
 const fast_equals_1 = require("fast-equals");
 const bindAll_1 = __importDefault(require("lodash/bindAll"));
 const utils_1 = __importDefault(require("./utils"));
-const Str = __importStar(require("./Str"));
+const OnyxKeys_1 = __importDefault(require("./OnyxKeys"));
 // Task constants
 const TASK = {
     GET: 'get',
@@ -62,10 +29,6 @@ class OnyxCache {
         this.evictionBlocklist = {};
         /** List of keys that have been directly subscribed to or recently modified from least to most recent */
         this.recentlyAccessedKeys = new Set();
-        /** Set of collection keys for fast lookup */
-        this.collectionKeys = new Set();
-        /** Set of RAM-only keys for fast lookup */
-        this.ramOnlyKeys = new Set();
         this.storageKeys = new Set();
         this.nullishStorageKeys = new Set();
         this.recentKeys = new Set();
@@ -73,7 +36,7 @@ class OnyxCache {
         this.collectionData = {};
         this.pendingPromises = new Map();
         // bind all public methods to prevent problems with `this`
-        (0, bindAll_1.default)(this, 'getAllKeys', 'get', 'hasCacheForKey', 'addKey', 'addNullishStorageKey', 'hasNullishStorageKey', 'clearNullishStorageKeys', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'addToAccessedKeys', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit', 'setAllKeys', 'setEvictionAllowList', 'getEvictionBlocklist', 'isEvictableKey', 'removeLastAccessedKey', 'addLastAccessedKey', 'addEvictableKeysToRecentlyAccessedList', 'getKeyForEviction', 'setCollectionKeys', 'isCollectionKey', 'getCollectionKey', 'getCollectionData', 'setRamOnlyKeys', 'isRamOnlyKey');
+        (0, bindAll_1.default)(this, 'getAllKeys', 'get', 'hasCacheForKey', 'addKey', 'addNullishStorageKey', 'hasNullishStorageKey', 'clearNullishStorageKeys', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'addToAccessedKeys', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit', 'setAllKeys', 'setEvictionAllowList', 'getEvictionBlocklist', 'isEvictableKey', 'removeLastAccessedKey', 'addLastAccessedKey', 'addEvictableKeysToRecentlyAccessedList', 'getKeyForEviction', 'setCollectionKeys', 'getCollectionData', 'hasValueChanged');
     }
     /** Get all the storage keys */
     getAllKeys() {
@@ -92,12 +55,16 @@ class OnyxCache {
      */
     setAllKeys(keys) {
         this.storageKeys = new Set(keys);
+        for (const key of keys) {
+            OnyxKeys_1.default.registerMemberKey(key);
+        }
     }
     /** Saves a key in the storage keys list
      * Serves to keep the result of `getAllKeys` up to date
      */
     addKey(key) {
         this.storageKeys.add(key);
+        OnyxKeys_1.default.registerMemberKey(key);
     }
     /** Used to set keys that are null/undefined in storage without adding null to the storage map */
     addNullishStorageKey(key) {
@@ -135,7 +102,7 @@ class OnyxCache {
         // When a key is explicitly set in cache, we can remove it from the list of nullish keys,
         // since it will either be set to a non nullish value or removed from the cache completely.
         this.nullishStorageKeys.delete(key);
-        const collectionKey = this.getCollectionKey(key);
+        const collectionKey = OnyxKeys_1.default.getCollectionKey(key);
         if (value === null || value === undefined) {
             delete this.storageMap[key];
             // Remove from collection data cache if it's a collection member
@@ -158,16 +125,17 @@ class OnyxCache {
     drop(key) {
         delete this.storageMap[key];
         // Remove from collection data cache if this is a collection member
-        const collectionKey = this.getCollectionKey(key);
+        const collectionKey = OnyxKeys_1.default.getCollectionKey(key);
         if (collectionKey && this.collectionData[collectionKey]) {
             delete this.collectionData[collectionKey][key];
         }
         // If this is a collection key, clear its data
-        if (this.isCollectionKey(key)) {
+        if (OnyxKeys_1.default.isCollectionKey(key)) {
             delete this.collectionData[key];
         }
         this.storageKeys.delete(key);
         this.recentKeys.delete(key);
+        OnyxKeys_1.default.deregisterMemberKey(key);
     }
     /**
      * Deep merge data to cache, any non existing keys will be created
@@ -184,7 +152,7 @@ class OnyxCache {
         for (const [key, value] of Object.entries(data)) {
             this.addKey(key);
             this.addToAccessedKeys(key);
-            const collectionKey = this.getCollectionKey(key);
+            const collectionKey = OnyxKeys_1.default.getCollectionKey(key);
             if (value === null || value === undefined) {
                 this.addNullishStorageKey(key);
                 // Remove from collection data cache if it's a collection member
@@ -260,7 +228,7 @@ class OnyxCache {
         for (const key of keysToRemove) {
             delete this.storageMap[key];
             // Remove from collection data cache if this is a collection member
-            const collectionKey = this.getCollectionKey(key);
+            const collectionKey = OnyxKeys_1.default.getCollectionKey(key);
             if (collectionKey && this.collectionData[collectionKey]) {
                 delete this.collectionData[collectionKey][key];
             }
@@ -294,16 +262,7 @@ class OnyxCache {
      * @param testKey - Key to check
      */
     isEvictableKey(testKey) {
-        return this.evictionAllowList.some((key) => this.isKeyMatch(key, testKey));
-    }
-    /**
-     * Check if a given key matches a pattern key
-     * @param configKey - Pattern that may contain a wildcard
-     * @param key - Key to test against the pattern
-     */
-    isKeyMatch(configKey, key) {
-        const isCollectionKey = configKey.endsWith('_');
-        return isCollectionKey ? Str.startsWith(key, configKey) : configKey === key;
+        return this.evictionAllowList.some((key) => OnyxKeys_1.default.isKeyMatch(key, testKey));
     }
     /**
      * Remove a key from the recently accessed key list.
@@ -336,7 +295,7 @@ class OnyxCache {
         return getAllKeysFn().then((keys) => {
             for (const evictableKey of this.evictionAllowList) {
                 for (const key of keys) {
-                    if (!this.isKeyMatch(evictableKey, key)) {
+                    if (!OnyxKeys_1.default.isKeyMatch(evictableKey, key)) {
                         continue;
                     }
                     this.addLastAccessedKey(key, isCollectionKeyFn(key));
@@ -359,7 +318,7 @@ class OnyxCache {
      * Set the collection keys for optimized storage
      */
     setCollectionKeys(collectionKeys) {
-        this.collectionKeys = collectionKeys;
+        OnyxKeys_1.default.setCollectionKeys(collectionKeys);
         // Initialize collection data for existing collection keys
         for (const collectionKey of collectionKeys) {
             if (this.collectionData[collectionKey]) {
@@ -368,23 +327,6 @@ class OnyxCache {
             this.collectionData[collectionKey] = {};
         }
     }
-    /**
-     * Check if a key is a collection key
-     */
-    isCollectionKey(key) {
-        return this.collectionKeys.has(key);
-    }
-    /**
-     * Get the collection key for a given member key
-     */
-    getCollectionKey(key) {
-        for (const collectionKey of this.collectionKeys) {
-            if (key.startsWith(collectionKey) && key.length > collectionKey.length) {
-                return collectionKey;
-            }
-        }
-        return undefined;
-    }
     /**
      * Get all data for a collection key
      */
@@ -396,18 +338,6 @@ class OnyxCache {
         // Return a shallow copy to ensure React detects changes when items are added/removed
         return Object.assign({}, cachedCollection);
     }
-    /**
-     * Set the RAM-only keys for optimized storage
-     */
-    setRamOnlyKeys(ramOnlyKeys) {
-        this.ramOnlyKeys = ramOnlyKeys;
-    }
-    /**
-     * Check if a key is a RAM-only key
-     */
-    isRamOnlyKey(key) {
-        return this.ramOnlyKeys.has(key);
-    }
 }
 const instance = new OnyxCache();
 exports.default = instance;

package/dist/OnyxConnectionManager.js

@@ -39,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const bindAll_1 = __importDefault(require("lodash/bindAll"));
 const Logger = __importStar(require("./Logger"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
+const OnyxKeys_1 = __importDefault(require("./OnyxKeys"));
 const Str = __importStar(require("./Str"));
 const OnyxCache_1 = __importDefault(require("./OnyxCache"));
 const OnyxSnapshotCache_1 = __importDefault(require("./OnyxSnapshotCache"));
@@ -71,7 +72,7 @@ class OnyxConnectionManager {
         //   in order to send all the collection entries, so the connection can't be reused.
         if (reuseConnection === false ||
             initWithStoredValues === false ||
-            (OnyxUtils_1.default.isCollectionKey(key) && (waitForCollectionCallback === undefined || waitForCollectionCallback === false))) {
+            (OnyxKeys_1.default.isCollectionKey(key) && (waitForCollectionCallback === undefined || waitForCollectionCallback === false))) {
             suffix += `,uniqueID=${Str.guid()}`;
         }
         return `onyxKey=${key},initWithStoredValues=${initWithStoredValues !== null && initWithStoredValues !== void 0 ? initWithStoredValues : true},waitForCollectionCallback=${waitForCollectionCallback !== null && waitForCollectionCallback !== void 0 ? waitForCollectionCallback : false}${suffix}`;

package/dist/OnyxKeys.d.ts

@@ -0,0 +1,93 @@
+import type { CollectionKeyBase, CollectionKey, OnyxKey } from './types';
+/**
+ * Initializes the collection key set. Called once during Onyx.init().
+ */
+declare function setCollectionKeys(keys: Set<OnyxKey>): void;
+/**
+ * Returns the set of all registered collection keys.
+ */
+declare function getCollectionKeys(): Set<OnyxKey>;
+/**
+ * Checks if the given key is a registered collection key (e.g. "report_").
+ */
+declare function isCollectionKey(key: OnyxKey): key is CollectionKeyBase;
+/**
+ * Checks if the given key is a member of the specified collection key.
+ * e.g. isCollectionMemberKey("report_", "report_123") → true
+ */
+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).
+ */
+declare function isCollectionMember(key: OnyxKey): boolean;
+/**
+ * Checks if the provided key matches the config key — either an exact match
+ * or a collection prefix match.
+ */
+declare function isKeyMatch(configKey: OnyxKey, key: OnyxKey): boolean;
+/**
+ * Extracts the collection key from a collection member key.
+ *
+ * Uses a pre-computed Map for O(1) lookup. Falls back to string parsing
+ * for keys not yet in the map (e.g. before they're cached).
+ *
+ * Examples:
+ * - getCollectionKey("report_123") → "report_"
+ * - getCollectionKey("report_") → "report_"
+ * - getCollectionKey("sharedNVP_user_-1_something") → "sharedNVP_user_"
+ */
+declare function getCollectionKey(key: CollectionKey | OnyxKey): string | undefined;
+/**
+ * Pre-computes and caches the member → collection key mapping for a given key.
+ * Called from OnyxCache.addKey() to ensure the Map stays populated.
+ */
+declare function registerMemberKey(key: OnyxKey): void;
+/**
+ * Removes a member key from the reverse lookup map.
+ * Called when a key is dropped from cache.
+ */
+declare function deregisterMemberKey(key: OnyxKey): void;
+/**
+ * Returns the set of member keys for a given collection key.
+ * O(1) lookup using the forward index.
+ */
+declare function getMembersOfCollection(collectionKey: OnyxKey): Set<OnyxKey> | undefined;
+/**
+ * Splits a collection member key into the collection key part and the ID part.
+ *
+ * @param key - The collection member key to split
+ * @param collectionKey - Optional pre-resolved collection key for optimization
+ * @returns A tuple of [collectionKey, memberId]
+ * @throws If the key is not a valid collection member key
+ */
+declare function splitCollectionMemberKey<TKey extends CollectionKey, CollectionKeyType = TKey extends `${infer Prefix}_${string}` ? `${Prefix}_` : never>(key: TKey, collectionKey?: string): [CollectionKeyType, string];
+/**
+ * Initializes the RAM-only key set. Called once during Onyx.init().
+ */
+declare function setRamOnlyKeys(keys: Set<OnyxKey>): void;
+/**
+ * Checks if a given key is a RAM-only key, RAM-only collection key, or a RAM-only collection member.
+ *
+ * For example, given ramOnlyKeys: ["ramOnlyKey", "ramOnlyCollection_"]:
+ * - isRamOnlyKey("ramOnlyKey") → true
+ * - isRamOnlyKey("ramOnlyCollection_") → true
+ * - isRamOnlyKey("ramOnlyCollection_1") → true
+ * - isRamOnlyKey("someOtherKey") → false
+ */
+declare function isRamOnlyKey(key: OnyxKey): boolean;
+declare const _default: {
+    setCollectionKeys: typeof setCollectionKeys;
+    getCollectionKeys: typeof getCollectionKeys;
+    isCollectionKey: typeof isCollectionKey;
+    isCollectionMemberKey: typeof isCollectionMemberKey;
+    isCollectionMember: typeof isCollectionMember;
+    isKeyMatch: typeof isKeyMatch;
+    getCollectionKey: typeof getCollectionKey;
+    registerMemberKey: typeof registerMemberKey;
+    deregisterMemberKey: typeof deregisterMemberKey;
+    getMembersOfCollection: typeof getMembersOfCollection;
+    splitCollectionMemberKey: typeof splitCollectionMemberKey;
+    setRamOnlyKeys: typeof setRamOnlyKeys;
+    isRamOnlyKey: typeof isRamOnlyKey;
+};
+export default _default;