react-native-onyx 3.0.53 → 3.0.55

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,
+};

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;