react-native-onyx 3.0.52 → 3.0.54

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.js

@@ -42,6 +42,7 @@ 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"));
@@ -58,19 +59,19 @@ function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedK
     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 +84,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 +195,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 +323,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 +334,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 +363,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 +460,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.

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;

package/dist/OnyxKeys.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Single source of truth for the set of registered collection keys */
+let collectionKeySet = new Set();
+/** Reverse lookup: member key → collection key for O(1) access */
+const memberToCollectionKeyMap = new Map();
+/** Forward lookup: collection key → set of member keys for O(collectionMembers) iteration */
+const collectionToMembersMap = new Map();
+/** Set of keys that should only be stored in RAM, not persisted to storage */
+let ramOnlyKeySet = new Set();
+/**
+ * Initializes the collection key set. Called once during Onyx.init().
+ */
+function setCollectionKeys(keys) {
+    collectionKeySet = keys;
+}
+/**
+ * Returns the set of all registered collection keys.
+ */
+function getCollectionKeys() {
+    return collectionKeySet;
+}
+/**
+ * Checks if the given key is a registered collection key (e.g. "report_").
+ */
+function isCollectionKey(key) {
+    return collectionKeySet.has(key);
+}
+/**
+ * Checks if the given key is a member of the specified collection key.
+ * e.g. isCollectionMemberKey("report_", "report_123") → true
+ */
+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).
+ */
+function isCollectionMember(key) {
+    const collectionKey = getCollectionKey(key);
+    return !!collectionKey && key.length > collectionKey.length;
+}
+/**
+ * Checks if the provided key matches the config key — either an exact match
+ * or a collection prefix match.
+ */
+function isKeyMatch(configKey, key) {
+    return isCollectionKey(configKey) ? key.startsWith(configKey) : configKey === key;
+}
+/**
+ * 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_"
+ */
+function getCollectionKey(key) {
+    // Fast path: O(1) Map lookup for known member keys
+    const cached = memberToCollectionKeyMap.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    // If the key itself is a collection key, return it directly
+    if (isCollectionKey(key)) {
+        return key;
+    }
+    // Slow path: string parsing — use a `string` variable to avoid
+    // TypeScript narrowing `key` to `never` after the isCollectionKey guard.
+    const keyStr = key;
+    let lastUnderscoreIndex = keyStr.lastIndexOf('_');
+    while (lastUnderscoreIndex > 0) {
+        const possibleKey = keyStr.slice(0, lastUnderscoreIndex + 1);
+        if (isCollectionKey(possibleKey)) {
+            // Cache for future O(1) lookups
+            memberToCollectionKeyMap.set(key, possibleKey);
+            return possibleKey;
+        }
+        lastUnderscoreIndex = keyStr.lastIndexOf('_', lastUnderscoreIndex - 1);
+    }
+    return undefined;
+}
+/**
+ * Pre-computes and caches the member → collection key mapping for a given key.
+ * Called from OnyxCache.addKey() to ensure the Map stays populated.
+ */
+function registerMemberKey(key) {
+    const existingCollectionKey = memberToCollectionKeyMap.get(key);
+    if (existingCollectionKey !== undefined) {
+        // Already in reverse map — ensure forward map is also populated.
+        // getCollectionKey() can populate memberToCollectionKeyMap without
+        // updating collectionToMembersMap, so we must sync here.
+        let members = collectionToMembersMap.get(existingCollectionKey);
+        if (!members) {
+            members = new Set();
+            collectionToMembersMap.set(existingCollectionKey, members);
+        }
+        members.add(key);
+        return;
+    }
+    // Find the longest (most specific) matching collection key.
+    // e.g. for 'test_level_1', prefer 'test_level_' over 'test_'.
+    let matchedCollectionKey;
+    for (const collectionKey of collectionKeySet) {
+        if (isCollectionMemberKey(collectionKey, key)) {
+            if (!matchedCollectionKey || collectionKey.length > matchedCollectionKey.length) {
+                matchedCollectionKey = collectionKey;
+            }
+        }
+    }
+    if (matchedCollectionKey) {
+        memberToCollectionKeyMap.set(key, matchedCollectionKey);
+        // Also register in the forward lookup (collection → members)
+        let members = collectionToMembersMap.get(matchedCollectionKey);
+        if (!members) {
+            members = new Set();
+            collectionToMembersMap.set(matchedCollectionKey, members);
+        }
+        members.add(key);
+    }
+}
+/**
+ * Removes a member key from the reverse lookup map.
+ * Called when a key is dropped from cache.
+ */
+function deregisterMemberKey(key) {
+    const collectionKey = memberToCollectionKeyMap.get(key);
+    if (collectionKey) {
+        const members = collectionToMembersMap.get(collectionKey);
+        if (members) {
+            members.delete(key);
+            if (members.size === 0) {
+                collectionToMembersMap.delete(collectionKey);
+            }
+        }
+    }
+    memberToCollectionKeyMap.delete(key);
+}
+/**
+ * Returns the set of member keys for a given collection key.
+ * O(1) lookup using the forward index.
+ */
+function getMembersOfCollection(collectionKey) {
+    return collectionToMembersMap.get(collectionKey);
+}
+/**
+ * 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
+ */
+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)];
+}
+/**
+ * Initializes the RAM-only key set. Called once during Onyx.init().
+ */
+function setRamOnlyKeys(keys) {
+    ramOnlyKeySet = keys;
+}
+/**
+ * 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
+ */
+function isRamOnlyKey(key) {
+    var _a;
+    return ramOnlyKeySet.has(key) || ramOnlyKeySet.has((_a = getCollectionKey(key)) !== null && _a !== void 0 ? _a : '');
+}
+exports.default = {
+    setCollectionKeys,
+    getCollectionKeys,
+    isCollectionKey,
+    isCollectionMemberKey,
+    isCollectionMember,
+    isKeyMatch,
+    getCollectionKey,
+    registerMemberKey,
+    deregisterMemberKey,
+    getMembersOfCollection,
+    splitCollectionMemberKey,
+    setRamOnlyKeys,
+    isRamOnlyKey,
+};