react-native-onyx 3.0.62 → 3.0.63

package/README.md

@@ -314,42 +314,24 @@ If a platform needs to use a separate library (like using MMVK for react-native)
 
 [Docs](./API.md)
 
-# Cache Eviction
+# Storage Eviction
 
 Different platforms come with varying storage capacities and Onyx has a way to gracefully fail when those storage limits are encountered. When Onyx fails to set or modify a key the following steps are taken:
-1. Onyx looks at a list of recently accessed keys (access is defined as subscribed to or modified) and locates the key that was least recently accessed
-2. It then deletes this key and retries the original operation
+1. Onyx looks at a list of evictable keys ordered by recent access and locates the least recently accessed one
+2. It then deletes this key from both cache and storage, and retries the original operation
+3. This process repeats up to 5 times until the write succeeds or no more evictable keys are available
 
 By default, Onyx will not evict anything from storage and will presume all keys are "unsafe" to remove unless explicitly told otherwise.
 
-**To flag a key as safe for removal:**
-- Add the key to the `evictableKeys` option in `Onyx.init(options)`
-- Implement `canEvict` in the Onyx config for each component subscribing to a key
-- The key will only be deleted when all subscribers return `true` for `canEvict`
+**To flag a key as safe for removal**, add the key to the `evictableKeys` option in `Onyx.init(options)`:
 
-e.g.
 ```js
 Onyx.init({
     evictableKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS],
 });
 ```
 
-```js
-const ReportActionsView = ({reportID, isActiveReport}) => {
-    const [reportActions] = useOnyx(
-        `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}_`,
-        {canEvict: () => !isActiveReport}
-    );
-
-    return (
-        <View>
-            {/* Render with reportActions data */}
-        </View>
-    );
-};
-
-export default ReportActionsView;
-```
+Only individual (non-collection) keys matching the `evictableKeys` patterns will be considered for eviction. Collection keys themselves cannot be evicted — only their individual members can.
 
 # Debug mode
 

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, enableDevTools, skippableCollectionMemberIDs, ramOnlyKeys, snapshotMergeKeys, }: InitOptions): void;
+declare function init({ keys, initialKeyStates, evictableKeys, 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

@@ -47,7 +47,7 @@ const logMessages_1 = __importDefault(require("./logMessages"));
 const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager"));
 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, enableDevTools = true, skippableCollectionMemberIDs = [], ramOnlyKeys = [], snapshotMergeKeys = [], }) {
+function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], shouldSyncMultipleInstances = !!global.localStorage, enableDevTools = true, skippableCollectionMemberIDs = [], ramOnlyKeys = [], snapshotMergeKeys = [], }) {
     var _a;
     (0, DevTools_1.initDevTools)(enableDevTools);
     storage_1.default.init();
@@ -69,9 +69,6 @@ function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedK
             OnyxUtils_1.default.keyChanged(key, value, undefined, isKeyCollectionMember);
         });
     }
-    if (maxCachedKeysCount > 0) {
-        OnyxCache_1.default.setRecentKeysLimit(maxCachedKeysCount);
-    }
     OnyxUtils_1.default.initStoreValues(keys, initialKeyStates, evictableKeys);
     // Initialize all of our keys with data provided then give green light to any pending connections.
     // addEvictableKeysToRecentlyAccessedList must run after initializeWithDefaultKeyStates because

package/dist/OnyxCache.d.ts

@@ -15,8 +15,6 @@ declare class OnyxCache {
     private storageKeys;
     /** A list of keys where a nullish value has been fetched from storage before, but the key still exists in cache */
     private nullishStorageKeys;
-    /** Unique list of keys maintained in access order (most recent at the end) */
-    private recentKeys;
     /** A map of cached values */
     private storageMap;
     /** Cache of complete collection data objects for O(1) retrieval */
@@ -26,12 +24,8 @@ declare class OnyxCache {
      * Using a map yields better performance on operations such a delete
      */
     private pendingPromises;
-    /** Maximum size of the keys store din cache */
-    private maxRecentKeysSize;
     /** List of keys that are safe to remove when we reach max storage */
     private evictionAllowList;
-    /** Map of keys and connection arrays whose keys will never be automatically evicted */
-    private evictionBlocklist;
     /** List of keys that have been directly subscribed to or recently modified from least to most recent */
     private recentlyAccessedKeys;
     constructor();
@@ -61,11 +55,8 @@ declare class OnyxCache {
     clearNullishStorageKeys(): void;
     /** Check whether cache has data for the given key */
     hasCacheForKey(key: OnyxKey): boolean;
-    /**
-     * Get a cached value from storage
-     * @param [shouldReindexCache] – This is an LRU cache, and by default accessing a value will make it become last in line to be evicted. This flag can be used to skip that and just access the value directly without side-effects.
-     */
-    get(key: OnyxKey, shouldReindexCache?: boolean): OnyxValue<OnyxKey>;
+    /** Get a cached value from storage */
+    get(key: OnyxKey): OnyxValue<OnyxKey>;
     /**
      * Set's a key value in cache
      * Adds the key to the storage keys list as well
@@ -96,12 +87,6 @@ declare class OnyxCache {
      * @param taskName - unique name for the task
      */
     captureTask(taskName: CacheTask, promise: Promise<OnyxValue<OnyxKey>>): Promise<OnyxValue<OnyxKey>>;
-    /** Adds a key to the top of the recently accessed keys */
-    addToAccessedKeys(key: OnyxKey): void;
-    /** Remove keys that don't fall into the range of recently used keys */
-    removeLeastRecentlyUsedKeys(): void;
-    /** Set the recent keys list size */
-    setRecentKeysLimit(limit: number): void;
     /** Check if the value has changed */
     hasValueChanged(key: OnyxKey, value: OnyxValue<OnyxKey>): boolean;
     /**
@@ -109,10 +94,6 @@ declare class OnyxCache {
      * @param keys - Array of OnyxKeys that are safe to evict
      */
     setEvictionAllowList(keys: OnyxKey[]): void;
-    /**
-     * Get the eviction block list that prevents keys from being evicted
-     */
-    getEvictionBlocklist(): Record<OnyxKey, string[] | undefined>;
     /**
      * Checks to see if this key has been flagged as safe for removal.
      * @param testKey - Key to check
@@ -138,7 +119,7 @@ declare class OnyxCache {
      */
     addEvictableKeysToRecentlyAccessedList(isCollectionKeyFn: (key: OnyxKey) => boolean, getAllKeysFn: () => Promise<Set<OnyxKey>>): Promise<void>;
     /**
-     * Finds a key that can be safely evicted
+     * Finds the least recently accessed key that can be safely evicted from storage.
      */
     getKeyForEviction(): OnyxKey | undefined;
     /**

package/dist/OnyxCache.js

@@ -21,22 +21,17 @@ exports.TASK = TASK;
  */
 class OnyxCache {
     constructor() {
-        /** Maximum size of the keys store din cache */
-        this.maxRecentKeysSize = 0;
         /** List of keys that are safe to remove when we reach max storage */
         this.evictionAllowList = [];
-        /** Map of keys and connection arrays whose keys will never be automatically evicted */
-        this.evictionBlocklist = {};
         /** List of keys that have been directly subscribed to or recently modified from least to most recent */
         this.recentlyAccessedKeys = new Set();
         this.storageKeys = new Set();
         this.nullishStorageKeys = new Set();
-        this.recentKeys = new Set();
         this.storageMap = {};
         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', 'getCollectionData', 'hasValueChanged');
+        (0, bindAll_1.default)(this, 'getAllKeys', 'get', 'hasCacheForKey', 'addKey', 'addNullishStorageKey', 'hasNullishStorageKey', 'clearNullishStorageKeys', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'setAllKeys', 'setEvictionAllowList', 'isEvictableKey', 'removeLastAccessedKey', 'addLastAccessedKey', 'addEvictableKeysToRecentlyAccessedList', 'getKeyForEviction', 'setCollectionKeys', 'getCollectionData', 'hasValueChanged');
     }
     /** Get all the storage keys */
     getAllKeys() {
@@ -82,14 +77,8 @@ class OnyxCache {
     hasCacheForKey(key) {
         return this.storageMap[key] !== undefined || this.hasNullishStorageKey(key);
     }
-    /**
-     * Get a cached value from storage
-     * @param [shouldReindexCache] – This is an LRU cache, and by default accessing a value will make it become last in line to be evicted. This flag can be used to skip that and just access the value directly without side-effects.
-     */
-    get(key, shouldReindexCache = true) {
-        if (shouldReindexCache) {
-            this.addToAccessedKeys(key);
-        }
+    /** Get a cached value from storage */
+    get(key) {
         return this.storageMap[key];
     }
     /**
@@ -98,7 +87,6 @@ class OnyxCache {
      */
     set(key, value) {
         this.addKey(key);
-        this.addToAccessedKeys(key);
         // 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);
@@ -134,7 +122,6 @@ class OnyxCache {
             delete this.collectionData[key];
         }
         this.storageKeys.delete(key);
-        this.recentKeys.delete(key);
         OnyxKeys_1.default.deregisterMemberKey(key);
     }
     /**
@@ -151,7 +138,6 @@ class OnyxCache {
         }).result);
         for (const [key, value] of Object.entries(data)) {
             this.addKey(key);
-            this.addToAccessedKeys(key);
             const collectionKey = OnyxKeys_1.default.getCollectionKey(key);
             if (value === null || value === undefined) {
                 this.addNullishStorageKey(key);
@@ -200,48 +186,9 @@ class OnyxCache {
         this.pendingPromises.set(taskName, returnPromise);
         return returnPromise;
     }
-    /** Adds a key to the top of the recently accessed keys */
-    addToAccessedKeys(key) {
-        this.recentKeys.delete(key);
-        this.recentKeys.add(key);
-    }
-    /** Remove keys that don't fall into the range of recently used keys */
-    removeLeastRecentlyUsedKeys() {
-        const numKeysToRemove = this.recentKeys.size - this.maxRecentKeysSize;
-        if (numKeysToRemove <= 0) {
-            return;
-        }
-        const iterator = this.recentKeys.values();
-        const keysToRemove = [];
-        const recentKeysArray = Array.from(this.recentKeys);
-        const mostRecentKey = recentKeysArray[recentKeysArray.length - 1];
-        let iterResult = iterator.next();
-        while (!iterResult.done) {
-            const key = iterResult.value;
-            // Don't consider the most recently accessed key for eviction
-            // This ensures we don't immediately evict a key we just added
-            if (key !== undefined && key !== mostRecentKey && this.isEvictableKey(key)) {
-                keysToRemove.push(key);
-            }
-            iterResult = iterator.next();
-        }
-        for (const key of keysToRemove) {
-            delete this.storageMap[key];
-            // Remove from collection data cache if this is a collection member
-            const collectionKey = OnyxKeys_1.default.getCollectionKey(key);
-            if (collectionKey && this.collectionData[collectionKey]) {
-                delete this.collectionData[collectionKey][key];
-            }
-            this.recentKeys.delete(key);
-        }
-    }
-    /** Set the recent keys list size */
-    setRecentKeysLimit(limit) {
-        this.maxRecentKeysSize = limit;
-    }
     /** Check if the value has changed */
     hasValueChanged(key, value) {
-        const currentValue = this.get(key, false);
+        const currentValue = this.get(key);
         return !(0, fast_equals_1.deepEqual)(currentValue, value);
     }
     /**
@@ -251,12 +198,6 @@ class OnyxCache {
     setEvictionAllowList(keys) {
         this.evictionAllowList = keys;
     }
-    /**
-     * Get the eviction block list that prevents keys from being evicted
-     */
-    getEvictionBlocklist() {
-        return this.evictionBlocklist;
-    }
     /**
      * Checks to see if this key has been flagged as safe for removal.
      * @param testKey - Key to check
@@ -304,15 +245,12 @@ class OnyxCache {
         });
     }
     /**
-     * Finds a key that can be safely evicted
+     * Finds the least recently accessed key that can be safely evicted from storage.
      */
     getKeyForEviction() {
-        for (const key of this.recentlyAccessedKeys) {
-            if (!this.evictionBlocklist[key]) {
-                return key;
-            }
-        }
-        return undefined;
+        // recentlyAccessedKeys is ordered from least to most recently accessed,
+        // so the first element is the best candidate for eviction.
+        return this.recentlyAccessedKeys.values().next().value;
     }
     /**
      * Set the collection keys for optimized storage

package/dist/OnyxConnectionManager.d.ts

@@ -72,15 +72,6 @@ declare class OnyxConnectionManager {
      * Refreshes the connection manager's session ID.
      */
     refreshSessionID(): void;
-    /**
-     * Adds the connection to the eviction block list. Connections added to this list can never be evicted.
-     * */
-    addToEvictionBlockList(connection: Connection): void;
-    /**
-     * Removes a connection previously added to this list
-     * which will enable it to be evicted again.
-     */
-    removeFromEvictionBlockList(connection: Connection): void;
 }
 declare const connectionManager: OnyxConnectionManager;
 export default connectionManager;

package/dist/OnyxConnectionManager.js

@@ -41,7 +41,6 @@ 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"));
 /**
  * Manages Onyx connections of `Onyx.connect()` and `useOnyx()` subscribers.
@@ -52,7 +51,7 @@ class OnyxConnectionManager {
         this.lastCallbackID = 0;
         this.sessionID = Str.guid();
         // Binds all public methods to prevent problems with `this`.
-        (0, bindAll_1.default)(this, 'generateConnectionID', 'fireCallbacks', 'connect', 'disconnect', 'disconnectAll', 'refreshSessionID', 'addToEvictionBlockList', 'removeFromEvictionBlockList');
+        (0, bindAll_1.default)(this, 'generateConnectionID', 'fireCallbacks', 'connect', 'disconnect', 'disconnectAll', 'refreshSessionID');
     }
     /**
      * Generates a connection ID based on the `connectOptions` object passed to the function.
@@ -164,7 +163,6 @@ class OnyxConnectionManager {
         // If the connection's callbacks map is empty we can safely unsubscribe from the Onyx key.
         if (connectionMetadata.callbacks.size === 0) {
             OnyxUtils_1.default.unsubscribeFromKey(connectionMetadata.subscriptionID);
-            this.removeFromEvictionBlockList(connection);
             this.connectionsMap.delete(connection.id);
         }
     }
@@ -172,11 +170,8 @@ class OnyxConnectionManager {
      * Disconnect all subscribers from Onyx.
      */
     disconnectAll() {
-        for (const [connectionID, connectionMetadata] of this.connectionsMap.entries()) {
+        for (const connectionMetadata of this.connectionsMap.values()) {
             OnyxUtils_1.default.unsubscribeFromKey(connectionMetadata.subscriptionID);
-            for (const callbackID of connectionMetadata.callbacks.keys()) {
-                this.removeFromEvictionBlockList({ id: connectionID, callbackID });
-            }
         }
         this.connectionsMap.clear();
         // Clear snapshot cache when all connections are disconnected
@@ -190,49 +185,6 @@ class OnyxConnectionManager {
         // Clear snapshot cache when session refreshes to avoid stale cache issues
         OnyxSnapshotCache_1.default.clear();
     }
-    /**
-     * Adds the connection to the eviction block list. Connections added to this list can never be evicted.
-     * */
-    addToEvictionBlockList(connection) {
-        var _a;
-        if (!connection) {
-            Logger.logInfo(`[ConnectionManager] Attempted to add connection to eviction block list passing an undefined connection object.`);
-            return;
-        }
-        const connectionMetadata = this.connectionsMap.get(connection.id);
-        if (!connectionMetadata) {
-            Logger.logInfo(`[ConnectionManager] Attempted to add connection to eviction block list but no connection was found.`);
-            return;
-        }
-        const evictionBlocklist = OnyxCache_1.default.getEvictionBlocklist();
-        if (!evictionBlocklist[connectionMetadata.onyxKey]) {
-            evictionBlocklist[connectionMetadata.onyxKey] = [];
-        }
-        (_a = evictionBlocklist[connectionMetadata.onyxKey]) === null || _a === void 0 ? void 0 : _a.push(`${connection.id}_${connection.callbackID}`);
-    }
-    /**
-     * Removes a connection previously added to this list
-     * which will enable it to be evicted again.
-     */
-    removeFromEvictionBlockList(connection) {
-        var _a, _b, _c;
-        if (!connection) {
-            Logger.logInfo(`[ConnectionManager] Attempted to remove connection from eviction block list passing an undefined connection object.`);
-            return;
-        }
-        const connectionMetadata = this.connectionsMap.get(connection.id);
-        if (!connectionMetadata) {
-            Logger.logInfo(`[ConnectionManager] Attempted to remove connection from eviction block list but no connection was found.`);
-            return;
-        }
-        const evictionBlocklist = OnyxCache_1.default.getEvictionBlocklist();
-        evictionBlocklist[connectionMetadata.onyxKey] =
-            (_b = (_a = evictionBlocklist[connectionMetadata.onyxKey]) === null || _a === void 0 ? void 0 : _a.filter((evictionKey) => evictionKey !== `${connection.id}_${connection.callbackID}`)) !== null && _b !== void 0 ? _b : [];
-        // Remove the key if there are no more subscribers.
-        if (((_c = evictionBlocklist[connectionMetadata.onyxKey]) === null || _c === void 0 ? void 0 : _c.length) === 0) {
-            delete evictionBlocklist[connectionMetadata.onyxKey];
-        }
-    }
 }
 const connectionManager = new OnyxConnectionManager();
 exports.default = connectionManager;

package/dist/OnyxSnapshotCache.d.ts

@@ -40,7 +40,7 @@ declare class OnyxSnapshotCache {
      * - `selector`: Different selectors produce different results, so each selector needs its own cache entry
      * - `initWithStoredValues`: This flag changes the initial loading behavior and affects the returned fetch status
      *
-     * Other options like `canEvict` and `reuseConnection` don't affect the data transformation
+     * Other options like `reuseConnection` don't affect the data transformation
      * or timing behavior of getSnapshot, so they're excluded from the cache key for better cache hit rates.
      */
     registerConsumer<TKey extends OnyxKey, TReturnValue>(options: Pick<UseOnyxOptions<TKey, TReturnValue>, 'selector' | 'initWithStoredValues'>): string;

package/dist/OnyxSnapshotCache.js

@@ -37,7 +37,7 @@ class OnyxSnapshotCache {
      * - `selector`: Different selectors produce different results, so each selector needs its own cache entry
      * - `initWithStoredValues`: This flag changes the initial loading behavior and affects the returned fetch status
      *
-     * Other options like `canEvict` and `reuseConnection` don't affect the data transformation
+     * Other options like `reuseConnection` don't affect the data transformation
      * or timing behavior of getSnapshot, so they're excluded from the cache key for better cache hit rates.
      */
     registerConsumer(options) {

package/dist/OnyxUtils.d.ts

@@ -127,11 +127,6 @@ declare function keyChanged<TKey extends OnyxKey>(key: TKey, value: OnyxValue<TK
  * Sends the data obtained from the keys to the connection.
  */
 declare function sendDataToConnection<TKey extends OnyxKey>(mapping: CallbackToStateMapping<TKey>, matchedKey: TKey | undefined): void;
-/**
- * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
- * run out of storage the least recently accessed key can be removed.
- */
-declare function addKeyToRecentlyAccessedIfNeeded<TKey extends OnyxKey>(key: TKey): void;
 /**
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
  */
@@ -312,7 +307,6 @@ declare const OnyxUtils: {
     setSnapshotMergeKeys: typeof setSnapshotMergeKeys;
     storeKeyBySubscriptions: typeof storeKeyBySubscriptions;
     deleteKeyBySubscriptions: typeof deleteKeyBySubscriptions;
-    addKeyToRecentlyAccessedIfNeeded: typeof addKeyToRecentlyAccessedIfNeeded;
     reduceCollectionWithSelector: typeof reduceCollectionWithSelector;
     updateSnapshots: typeof updateSnapshots;
     mergeCollectionWithPatches: typeof mergeCollectionWithPatches;

package/dist/OnyxUtils.js

@@ -521,8 +521,8 @@ function keysChanged(collectionKey, partialCollection, partialPreviousCollection
  */
 function keyChanged(key, value, canUpdateSubscriber = () => true, isProcessingCollectionUpdate = false) {
     var _a, _b;
-    // Add or remove this key from the recentlyAccessedKeys lists
-    if (value !== null) {
+    // Add or remove this key from the recentlyAccessedKeys list
+    if (value !== null && value !== undefined) {
         OnyxCache_1.default.addLastAccessedKey(key, OnyxKeys_1.default.isCollectionKey(key));
     }
     else {
@@ -616,19 +616,6 @@ function sendDataToConnection(mapping, matchedKey) {
     }
     (_b = (_a = mapping).callback) === null || _b === void 0 ? void 0 : _b.call(_a, value, matchedKey);
 }
-/**
- * We check to see if this key is flagged as safe for eviction and add it to the recentlyAccessedKeys list so that when we
- * run out of storage the least recently accessed key can be removed.
- */
-function addKeyToRecentlyAccessedIfNeeded(key) {
-    if (!OnyxCache_1.default.isEvictableKey(key)) {
-        return;
-    }
-    // Add the key to recentKeys first (this makes it the most recent key)
-    OnyxCache_1.default.addToAccessedKeys(key);
-    // Try to free some cache whenever we connect to a safe eviction key
-    OnyxCache_1.default.removeLeastRecentlyUsedKeys();
-}
 /**
  * Gets the data for a given an array of matching keys, combines them into an object, and sends the result back to the subscriber.
  */
@@ -683,7 +670,7 @@ function retryOperation(error, onyxMethod, defaultParams, retryAttempt) {
         // @ts-expect-error No overload matches this call.
         return onyxMethod(defaultParams, nextRetryAttempt);
     }
-    // Find the first key that we can remove that has no subscribers in our blocklist
+    // Find the least recently accessed evictable key that we can remove
     const keyForRemoval = OnyxCache_1.default.getKeyForEviction();
     if (!keyForRemoval) {
         // If we have no acceptable keys to remove then we are possibly trying to save mission critical data. If this is the case,
@@ -692,7 +679,7 @@ function retryOperation(error, onyxMethod, defaultParams, retryAttempt) {
         Logger.logAlert('Out of storage. But found no acceptable keys to remove.');
         return reportStorageQuota();
     }
-    // Remove the least recently viewed key that is not currently being accessed and retry.
+    // Remove the least recently accessed key and retry.
     Logger.logInfo(`Out of storage. Evicting least recently accessed key (${keyForRemoval}) and retrying.`);
     reportStorageQuota();
     // @ts-expect-error No overload matches this call.
@@ -707,9 +694,6 @@ function broadcastUpdate(key, value, hasChanged) {
     if (hasChanged) {
         OnyxCache_1.default.set(key, value);
     }
-    else {
-        OnyxCache_1.default.addToAccessedKeys(key);
-    }
     keyChanged(key, value, (subscriber) => hasChanged || (subscriber === null || subscriber === void 0 ? void 0 : subscriber.initWithStoredValues) === false);
 }
 function hasPendingMergeForKey(key) {
@@ -893,7 +877,9 @@ function subscribeToKey(connectOptions) {
     }
     // Commit connection only after init passes
     deferredInitTask.promise
-        .then(() => addKeyToRecentlyAccessedIfNeeded(mapping.key))
+        // This first .then() adds a microtask tick for compatibility reasons and
+        // to ensure subscribers don't receive an extra initial callback before Onyx.update() data arrives.
+        .then(() => undefined)
         .then(() => {
         // Performance improvement
         // If the mapping is connected to an onyx key that is not a collection
@@ -1060,7 +1046,7 @@ function setWithRetry({ key, value, options }, retryAttempt) {
     if (value === undefined) {
         return Promise.resolve();
     }
-    const existingValue = OnyxCache_1.default.get(key, false);
+    const existingValue = OnyxCache_1.default.get(key);
     // If the existing value as well as the new value are null, we can return early.
     if (existingValue === undefined && value === null) {
         return Promise.resolve();
@@ -1439,7 +1425,6 @@ const OnyxUtils = {
     setSnapshotMergeKeys,
     storeKeyBySubscriptions,
     deleteKeyBySubscriptions,
-    addKeyToRecentlyAccessedIfNeeded,
     reduceCollectionWithSelector,
     updateSnapshots,
     mergeCollectionWithPatches,

package/dist/types.d.ts

@@ -334,15 +334,9 @@ type InitOptions = {
     initialKeyStates?: Partial<OnyxInputKeyValueMapping>;
     /**
      * This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged
-     * as "safe" for removal. Any components subscribing to these keys must also implement a canEvict option. See the README for more info.
+     * as "safe" for removal.
      */
     evictableKeys?: OnyxKey[];
-    /**
-     * Sets how many recent keys should we try to keep in cache
-     * Setting this to 0 would practically mean no cache
-     * We try to free cache when we connect to a safe eviction key
-     */
-    maxCachedKeysCount?: number;
     /**
      * Auto synchronize storage events between multiple instances
      * of Onyx running in different tabs/windows. Defaults to true for platforms that support local storage (web/desktop)

package/dist/useOnyx.d.ts

@@ -2,10 +2,6 @@ import type { DependencyList } from 'react';
 import type { OnyxKey, OnyxValue } from './types';
 type UseOnyxSelector<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>> = (data: OnyxValue<TKey> | undefined) => TReturnValue;
 type UseOnyxOptions<TKey extends OnyxKey, TReturnValue> = {
-    /**
-     * Determines if this key in this subscription is safe to be evicted.
-     */
-    canEvict?: boolean;
     /**
      * If set to `false`, then no data will be prefilled into the component.
      * @deprecated This param is going to be removed soon. Use RAM-only keys instead.

package/dist/useOnyx.js

@@ -132,20 +132,6 @@ function useOnyx(key, options, dependencies = []) {
         onStoreChangeFnRef.current();
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [...dependencies]);
-    const checkEvictableKey = (0, react_1.useCallback)(() => {
-        if ((options === null || options === void 0 ? void 0 : options.canEvict) === undefined || !connectionRef.current) {
-            return;
-        }
-        if (!OnyxCache_1.default.isEvictableKey(key)) {
-            throw new Error(`canEvict can't be used on key '${key}'. This key must explicitly be flagged as safe for removal by adding it to Onyx.init({evictableKeys: []}).`);
-        }
-        if (options.canEvict) {
-            OnyxConnectionManager_1.default.removeFromEvictionBlockList(connectionRef.current);
-        }
-        else {
-            OnyxConnectionManager_1.default.addToEvictionBlockList(connectionRef.current);
-        }
-    }, [key, options === null || options === void 0 ? void 0 : options.canEvict]);
     // Tracks the last memoizedSelector reference that getSnapshot() has computed with.
     // When the selector changes, this mismatch forces getSnapshot() to re-evaluate
     // even if all other conditions (isFirstConnection, shouldGetCachedValue, key) are false.
@@ -262,7 +248,6 @@ function useOnyx(key, options, dependencies = []) {
             waitForCollectionCallback: OnyxKeys_1.default.isCollectionKey(key),
             reuseConnection: options === null || options === void 0 ? void 0 : options.reuseConnection,
         });
-        checkEvictableKey();
         return () => {
             if (!connectionRef.current) {
                 return;
@@ -272,10 +257,7 @@ function useOnyx(key, options, dependencies = []) {
             isConnectingRef.current = false;
             onStoreChangeFnRef.current = null;
         };
-    }, [key, options === null || options === void 0 ? void 0 : options.initWithStoredValues, options === null || options === void 0 ? void 0 : options.reuseConnection, checkEvictableKey]);
-    (0, react_1.useEffect)(() => {
-        checkEvictableKey();
-    }, [checkEvictableKey]);
+    }, [key, options === null || options === void 0 ? void 0 : options.initWithStoredValues, options === null || options === void 0 ? void 0 : options.reuseConnection]);
     const result = (0, react_1.useSyncExternalStore)(subscribe, getSnapshot);
     return result;
 }

package/package.json

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