react-native-onyx 2.0.103 → 2.0.104

package/README.md

@@ -388,14 +388,14 @@ Different platforms come with varying storage capacities and Onyx has a way to g
 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 `safeEvictionKeys` option in `Onyx.init(options)`
+- 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`
 
 e.g.
 ```js
 Onyx.init({
-    safeEvictionKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS],
+    evictableKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS],
 });
 ```
 
@@ -423,7 +423,7 @@ Provide the `captureMetrics` boolean flag to `Onyx.init` to capture call statist
 ```js
 Onyx.init({
     keys: ONYXKEYS,
-    safeEvictionKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS],
+    evictableKeys: [ONYXKEYS.COLLECTION.REPORT_ACTIONS],
     captureMetrics: Config.BENCHMARK_ONYX,
 });
 ```

package/dist/Onyx.d.ts

@@ -2,7 +2,7 @@ import * as Logger from './Logger';
 import type { CollectionKeyBase, ConnectOptions, InitOptions, Mapping, OnyxKey, OnyxMergeCollectionInput, OnyxMergeInput, OnyxMultiSetInput, OnyxSetInput, OnyxUpdate } from './types';
 import type { Connection } from './OnyxConnectionManager';
 /** Initialize the store with actions and listening for storage events */
-declare function init({ keys, initialKeyStates, safeEvictionKeys, maxCachedKeysCount, shouldSyncMultipleInstances, debugSetState, enablePerformanceMetrics, skippableCollectionMemberIDs, }: InitOptions): void;
+declare function init({ keys, initialKeyStates, evictableKeys, maxCachedKeysCount, shouldSyncMultipleInstances, debugSetState, enablePerformanceMetrics, skippableCollectionMemberIDs, }: InitOptions): void;
 /**
  * Connects to an Onyx key given the options passed and listens to its changes.
  *

package/dist/Onyx.js

@@ -40,7 +40,7 @@ const OnyxConnectionManager_1 = __importDefault(require("./OnyxConnectionManager
 const GlobalSettings = __importStar(require("./GlobalSettings"));
 const metrics_1 = __importDefault(require("./metrics"));
 /** Initialize the store with actions and listening for storage events */
-function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = !!global.localStorage, debugSetState = false, enablePerformanceMetrics = false, skippableCollectionMemberIDs = [], }) {
+function init({ keys = {}, initialKeyStates = {}, evictableKeys = [], maxCachedKeysCount = 1000, shouldSyncMultipleInstances = !!global.localStorage, debugSetState = false, enablePerformanceMetrics = false, skippableCollectionMemberIDs = [], }) {
     var _a;
     if (enablePerformanceMetrics) {
         GlobalSettings.setPerformanceMetricsEnabled(true);
@@ -61,9 +61,9 @@ function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCach
     if (maxCachedKeysCount > 0) {
         OnyxCache_1.default.setRecentKeysLimit(maxCachedKeysCount);
     }
-    OnyxUtils_1.default.initStoreValues(keys, initialKeyStates, safeEvictionKeys);
+    OnyxUtils_1.default.initStoreValues(keys, initialKeyStates, evictableKeys);
     // Initialize all of our keys with data provided then give green light to any pending connections
-    Promise.all([OnyxUtils_1.default.addAllSafeEvictionKeysToRecentlyAccessedList(), OnyxUtils_1.default.initializeWithDefaultKeyStates()]).then(OnyxUtils_1.default.getDeferredInitTask().resolve);
+    Promise.all([OnyxCache_1.default.addEvictableKeysToRecentlyAccessedList(OnyxUtils_1.default.isCollectionKey, OnyxUtils_1.default.getAllKeys), OnyxUtils_1.default.initializeWithDefaultKeyStates()]).then(OnyxUtils_1.default.getDeferredInitTask().resolve);
 }
 /**
  * Connects to an Onyx key given the options passed and listens to its changes.

package/dist/OnyxCache.d.ts

@@ -26,6 +26,12 @@ declare class OnyxCache {
     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();
     /** Get all the storage keys */
     getAllKeys(): Set<OnyxKey>;
@@ -96,6 +102,49 @@ declare class OnyxCache {
     setRecentKeysLimit(limit: number): void;
     /** Check if the value has changed */
     hasValueChanged(key: OnyxKey, value: OnyxValue<OnyxKey>): boolean;
+    /**
+     * Sets the list of keys that are considered safe for eviction
+     * @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
+     */
+    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.
+     */
+    removeLastAccessedKey(key: OnyxKey): void;
+    /**
+     * Add a key to the list of recently accessed keys. The least
+     * recently accessed key should be at the head and the most
+     * recently accessed key at the tail.
+     */
+    addLastAccessedKey(key: OnyxKey, isCollectionKey: boolean): void;
+    /**
+     * Take all the keys that are safe to evict and add them to
+     * the recently accessed list when initializing the app. This
+     * enables keys that have not recently been accessed to be
+     * removed.
+     * @param isCollectionKeyFn - Function to determine if a key is a collection key
+     * @param getAllKeysFn - Function to get all keys, defaults to Storage.getAllKeys
+     */
+    addEvictableKeysToRecentlyAccessedList(isCollectionKeyFn: (key: OnyxKey) => boolean, getAllKeysFn: () => Promise<Set<OnyxKey>>): Promise<void>;
+    /**
+     * Finds a key that can be safely evicted
+     */
+    getKeyForEviction(): OnyxKey | undefined;
 }
 declare const instance: OnyxCache;
 export default instance;

package/dist/OnyxCache.js

@@ -1,4 +1,27 @@
 "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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,6 +30,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"));
 // Task constants
 const TASK = {
     GET: 'get',
@@ -22,13 +46,19 @@ 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 = [];
         this.storageKeys = new Set();
         this.nullishStorageKeys = new Set();
         this.recentKeys = new Set();
         this.storageMap = {};
         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', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit', 'setAllKeys');
+        (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');
     }
     /** Get all the storage keys */
     getAllKeys() {
@@ -158,18 +188,25 @@ class OnyxCache {
     }
     /** Remove keys that don't fall into the range of recently used keys */
     removeLeastRecentlyUsedKeys() {
-        let numKeysToRemove = this.recentKeys.size - this.maxRecentKeysSize;
+        const numKeysToRemove = this.recentKeys.size - this.maxRecentKeysSize;
         if (numKeysToRemove <= 0) {
             return;
         }
         const iterator = this.recentKeys.values();
-        const temp = [];
-        while (numKeysToRemove > 0) {
-            const value = iterator.next().value;
-            temp.push(value);
-            numKeysToRemove--;
+        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 temp) {
+        for (const key of keysToRemove) {
             delete this.storageMap[key];
             this.recentKeys.delete(key);
         }
@@ -182,6 +219,80 @@ class OnyxCache {
     hasValueChanged(key, value) {
         return !(0, fast_equals_1.deepEqual)(this.storageMap[key], value);
     }
+    /**
+     * Sets the list of keys that are considered safe for eviction
+     * @param keys - Array of OnyxKeys that are safe to evict
+     */
+    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
+     */
+    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;
+    }
+    /**
+     * Remove a key from the recently accessed key list.
+     */
+    removeLastAccessedKey(key) {
+        this.recentlyAccessedKeys = this.recentlyAccessedKeys.filter((recentlyAccessedKey) => recentlyAccessedKey !== key);
+    }
+    /**
+     * Add a key to the list of recently accessed keys. The least
+     * recently accessed key should be at the head and the most
+     * recently accessed key at the tail.
+     */
+    addLastAccessedKey(key, isCollectionKey) {
+        // Only specific keys belong in this list since we cannot remove an entire collection.
+        if (isCollectionKey || !this.isEvictableKey(key)) {
+            return;
+        }
+        this.removeLastAccessedKey(key);
+        this.recentlyAccessedKeys.push(key);
+    }
+    /**
+     * Take all the keys that are safe to evict and add them to
+     * the recently accessed list when initializing the app. This
+     * enables keys that have not recently been accessed to be
+     * removed.
+     * @param isCollectionKeyFn - Function to determine if a key is a collection key
+     * @param getAllKeysFn - Function to get all keys, defaults to Storage.getAllKeys
+     */
+    addEvictableKeysToRecentlyAccessedList(isCollectionKeyFn, getAllKeysFn) {
+        return getAllKeysFn().then((keys) => {
+            this.evictionAllowList.forEach((evictableKey) => {
+                keys.forEach((key) => {
+                    if (!this.isKeyMatch(evictableKey, key)) {
+                        return;
+                    }
+                    this.addLastAccessedKey(key, isCollectionKeyFn(key));
+                });
+            });
+        });
+    }
+    /**
+     * Finds a key that can be safely evicted
+     */
+    getKeyForEviction() {
+        return this.recentlyAccessedKeys.find((key) => !this.evictionBlocklist[key]);
+    }
 }
 const instance = new OnyxCache();
 exports.default = instance;

package/dist/OnyxConnectionManager.js

@@ -31,6 +31,7 @@ const Logger = __importStar(require("./Logger"));
 const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 const Str = __importStar(require("./Str"));
 const utils_1 = __importDefault(require("./utils"));
+const OnyxCache_1 = __importDefault(require("./OnyxCache"));
 /**
  * Manages Onyx connections of `Onyx.connect()`, `useOnyx()` and `withOnyx()` subscribers.
  */
@@ -192,7 +193,7 @@ class OnyxConnectionManager {
             Logger.logInfo(`[ConnectionManager] Attempted to add connection to eviction block list but no connection was found.`);
             return;
         }
-        const evictionBlocklist = OnyxUtils_1.default.getEvictionBlocklist();
+        const evictionBlocklist = OnyxCache_1.default.getEvictionBlocklist();
         if (!evictionBlocklist[connectionMetadata.onyxKey]) {
             evictionBlocklist[connectionMetadata.onyxKey] = [];
         }
@@ -213,7 +214,7 @@ class OnyxConnectionManager {
             Logger.logInfo(`[ConnectionManager] Attempted to remove connection from eviction block list but no connection was found.`);
             return;
         }
-        const evictionBlocklist = OnyxUtils_1.default.getEvictionBlocklist();
+        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.

package/dist/OnyxUtils.d.ts

@@ -29,10 +29,6 @@ declare function getDefaultKeyStates(): Record<OnyxKey, OnyxValue<OnyxKey>>;
  * Getter - returns the deffered init task.
  */
 declare function getDeferredInitTask(): DeferredTask;
-/**
- * Getter - returns the eviction block list.
- */
-declare function getEvictionBlocklist(): Record<OnyxKey, string[] | undefined>;
 /**
  * Getter - returns the skippable collection member IDs.
  */
@@ -46,9 +42,9 @@ declare function setSkippableCollectionMemberIDs(ids: Set<string>): void;
  *
  * @param keys - `ONYXKEYS` constants object from Onyx.init()
  * @param initialKeyStates - initial data to set when `init()` and `clear()` are called
- * @param safeEvictionKeys - This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged as "safe" for removal.
+ * @param evictableKeys - This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged as "safe" for removal.
  */
-declare function initStoreValues(keys: DeepRecord<string, OnyxKey>, initialKeyStates: Partial<KeyValueMapping>, safeEvictionKeys: OnyxKey[]): void;
+declare function initStoreValues(keys: DeepRecord<string, OnyxKey>, initialKeyStates: Partial<KeyValueMapping>, evictableKeys: OnyxKey[]): void;
 /**
  * Sends an action to DevTools extension
  *
@@ -123,8 +119,6 @@ declare function splitCollectionMemberKey<TKey extends CollectionKey, Collection
  * 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;
-/** Checks to see if this key has been flagged as safe for removal. */
-declare function isSafeEvictionKey(testKey: OnyxKey): boolean;
 /**
  * Extracts the collection identifier of a given collection member key.
  *
@@ -143,23 +137,6 @@ declare function getCollectionKey(key: CollectionKey): string;
  * If the requested key is a collection, it will return an object with all the collection members.
  */
 declare function tryGetCachedValue<TKey extends OnyxKey>(key: TKey, mapping?: Partial<Mapping<TKey>>): OnyxValue<OnyxKey>;
-/**
- * Remove a key from the recently accessed key list.
- */
-declare function removeLastAccessedKey(key: OnyxKey): void;
-/**
- * Add a key to the list of recently accessed keys. The least
- * recently accessed key should be at the head and the most
- * recently accessed key at the tail.
- */
-declare function addLastAccessedKey(key: OnyxKey): void;
-/**
- * Take all the keys that are safe to evict and add them to
- * the recently accessed list when initializing the app. This
- * enables keys that have not recently been accessed to be
- * removed.
- */
-declare function addAllSafeEvictionKeysToRecentlyAccessedList(): Promise<void>;
 declare function getCachedCollection<TKey extends CollectionKeyBase>(collectionKey: TKey, collectionMemberKeys?: string[]): NonNullable<OnyxCollection<KeyValueMapping[TKey]>>;
 /**
  * When a collection of keys change, search for any callbacks matching the collection key and trigger those callbacks
@@ -292,11 +269,7 @@ declare const OnyxUtils: {
     isCollectionMemberKey: typeof isCollectionMemberKey;
     splitCollectionMemberKey: typeof splitCollectionMemberKey;
     isKeyMatch: typeof isKeyMatch;
-    isSafeEvictionKey: typeof isSafeEvictionKey;
     tryGetCachedValue: typeof tryGetCachedValue;
-    removeLastAccessedKey: typeof removeLastAccessedKey;
-    addLastAccessedKey: typeof addLastAccessedKey;
-    addAllSafeEvictionKeysToRecentlyAccessedList: typeof addAllSafeEvictionKeysToRecentlyAccessedList;
     getCachedCollection: typeof getCachedCollection;
     keysChanged: typeof keysChanged;
     keyChanged: typeof keyChanged;
@@ -321,7 +294,6 @@ declare const OnyxUtils: {
     doAllCollectionItemsBelongToSameParent: typeof doAllCollectionItemsBelongToSameParent;
     subscribeToKey: typeof subscribeToKey;
     unsubscribeFromKey: typeof unsubscribeFromKey;
-    getEvictionBlocklist: typeof getEvictionBlocklist;
     getSkippableCollectionMemberIDs: typeof getSkippableCollectionMemberIDs;
     setSkippableCollectionMemberIDs: typeof setSkippableCollectionMemberIDs;
     storeKeyBySubscriptions: typeof storeKeyBySubscriptions;

package/dist/OnyxUtils.js

@@ -59,14 +59,6 @@ const callbackToStateMapping = {};
 let onyxCollectionKeySet = new Set();
 // Holds a mapping of the connected key to the subscriptionID for faster lookups
 const onyxKeyToSubscriptionIDs = new Map();
-// Holds a list of keys that have been directly subscribed to or recently modified from least to most recent
-let recentlyAccessedKeys = [];
-// Holds a list of keys that are safe to remove when we reach max storage. If a key does not match with
-// whatever appears in this list it will NEVER be a candidate for eviction.
-let evictionAllowList = [];
-// Holds a map of keys and connection arrays whose keys will never be automatically evicted as
-// long as we have at least one subscriber that returns false for the canEvict property.
-const evictionBlocklist = {};
 // Optional user-provided key value states set when Onyx initializes or clears
 let defaultKeyStates = {};
 let batchUpdatesPromise = null;
@@ -107,12 +99,6 @@ function getDefaultKeyStates() {
 function getDeferredInitTask() {
     return deferredInitTask;
 }
-/**
- * Getter - returns the eviction block list.
- */
-function getEvictionBlocklist() {
-    return evictionBlocklist;
-}
 /**
  * Getter - returns the skippable collection member IDs.
  */
@@ -130,9 +116,9 @@ function setSkippableCollectionMemberIDs(ids) {
  *
  * @param keys - `ONYXKEYS` constants object from Onyx.init()
  * @param initialKeyStates - initial data to set when `init()` and `clear()` are called
- * @param safeEvictionKeys - This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged as "safe" for removal.
+ * @param evictableKeys - This is an array of keys (individual or collection patterns) that when provided to Onyx are flagged as "safe" for removal.
  */
-function initStoreValues(keys, initialKeyStates, safeEvictionKeys) {
+function initStoreValues(keys, initialKeyStates, evictableKeys) {
     var _a;
     // We need the value of the collection keys later for checking if a
     // key is a collection. We store it in a map for faster lookup.
@@ -145,7 +131,7 @@ function initStoreValues(keys, initialKeyStates, safeEvictionKeys) {
     defaultKeyStates = initialKeyStates;
     DevTools_1.default.initState(initialKeyStates);
     // Let Onyx know about which keys are safe to evict
-    evictionAllowList = safeEvictionKeys;
+    OnyxCache_1.default.setEvictionAllowList(evictableKeys);
     if (typeof keys.COLLECTION === 'object' && typeof keys.COLLECTION.SNAPSHOT === 'string') {
         snapshotKey = keys.COLLECTION.SNAPSHOT;
     }
@@ -403,10 +389,6 @@ function splitCollectionMemberKey(key, collectionKey) {
 function isKeyMatch(configKey, key) {
     return isCollectionKey(configKey) ? Str.startsWith(key, configKey) : configKey === key;
 }
-/** Checks to see if this key has been flagged as safe for removal. */
-function isSafeEvictionKey(testKey) {
-    return evictionAllowList.some((key) => isKeyMatch(key, testKey));
-}
 /**
  * Extracts the collection identifier of a given collection member key.
  *
@@ -466,43 +448,6 @@ function tryGetCachedValue(key, mapping) {
     }
     return val;
 }
-/**
- * Remove a key from the recently accessed key list.
- */
-function removeLastAccessedKey(key) {
-    recentlyAccessedKeys = recentlyAccessedKeys.filter((recentlyAccessedKey) => recentlyAccessedKey !== key);
-}
-/**
- * Add a key to the list of recently accessed keys. The least
- * recently accessed key should be at the head and the most
- * recently accessed key at the tail.
- */
-function addLastAccessedKey(key) {
-    // Only specific keys belong in this list since we cannot remove an entire collection.
-    if (isCollectionKey(key) || !isSafeEvictionKey(key)) {
-        return;
-    }
-    removeLastAccessedKey(key);
-    recentlyAccessedKeys.push(key);
-}
-/**
- * Take all the keys that are safe to evict and add them to
- * the recently accessed list when initializing the app. This
- * enables keys that have not recently been accessed to be
- * removed.
- */
-function addAllSafeEvictionKeysToRecentlyAccessedList() {
-    return getAllKeys().then((keys) => {
-        evictionAllowList.forEach((safeEvictionKey) => {
-            keys.forEach((key) => {
-                if (!isKeyMatch(safeEvictionKey, key)) {
-                    return;
-                }
-                addLastAccessedKey(key);
-            });
-        });
-    });
-}
 function getCachedCollection(collectionKey, collectionMemberKeys) {
     const allKeys = collectionMemberKeys || OnyxCache_1.default.getAllKeys();
     const collection = {};
@@ -688,10 +633,10 @@ function keyChanged(key, value, previousValue, canUpdateSubscriber = () => true,
     var _a, _b;
     // Add or remove this key from the recentlyAccessedKeys lists
     if (value !== null) {
-        addLastAccessedKey(key);
+        OnyxCache_1.default.addLastAccessedKey(key, isCollectionKey(key));
     }
     else {
-        removeLastAccessedKey(key);
+        OnyxCache_1.default.removeLastAccessedKey(key);
     }
     // We get the subscribers interested in the key that has just changed. If the subscriber's  key is a collection key then we will
     // notify them if the key that changed is a collection member. Or if it is a regular key notify them when there is an exact match. Depending on whether the subscriber
@@ -872,9 +817,11 @@ function sendDataToConnection(mapping, value, matchedKey, isBatched) {
  * run out of storage the least recently accessed key can be removed.
  */
 function addKeyToRecentlyAccessedIfNeeded(mapping) {
-    if (!isSafeEvictionKey(mapping.key)) {
+    if (!OnyxCache_1.default.isEvictableKey(mapping.key)) {
         return;
     }
+    // Add the key to recentKeys first (this makes it the most recent key)
+    OnyxCache_1.default.addToAccessedKeys(mapping.key);
     // Try to free some cache whenever we connect to a safe eviction key
     OnyxCache_1.default.removeLeastRecentlyUsedKeys();
     if (utils_1.default.hasWithOnyxInstance(mapping) && !isCollectionKey(mapping.key)) {
@@ -882,7 +829,7 @@ function addKeyToRecentlyAccessedIfNeeded(mapping) {
         if (mapping.canEvict === undefined) {
             throw new Error(`Cannot subscribe to safe eviction key '${mapping.key}' without providing a canEvict value.`);
         }
-        addLastAccessedKey(mapping.key);
+        OnyxCache_1.default.addLastAccessedKey(mapping.key, isCollectionKey(mapping.key));
     }
 }
 /**
@@ -945,7 +892,7 @@ function evictStorageAndRetry(error, onyxMethod, ...args) {
         throw error;
     }
     // Find the first key that we can remove that has no subscribers in our blocklist
-    const keyForRemoval = recentlyAccessedKeys.find((key) => !evictionBlocklist[key]);
+    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,
         // then we should stop retrying as there is not much the user can do to fix this. Instead of getting them stuck in an infinite loop we
@@ -1231,11 +1178,7 @@ const OnyxUtils = {
     isCollectionMemberKey,
     splitCollectionMemberKey,
     isKeyMatch,
-    isSafeEvictionKey,
     tryGetCachedValue,
-    removeLastAccessedKey,
-    addLastAccessedKey,
-    addAllSafeEvictionKeysToRecentlyAccessedList,
     getCachedCollection,
     keysChanged,
     keyChanged,
@@ -1260,7 +1203,6 @@ const OnyxUtils = {
     doAllCollectionItemsBelongToSameParent,
     subscribeToKey,
     unsubscribeFromKey,
-    getEvictionBlocklist,
     getSkippableCollectionMemberIDs,
     setSkippableCollectionMemberIDs,
     storeKeyBySubscriptions,
@@ -1287,7 +1229,7 @@ GlobalSettings.addGlobalSettingsChangeListener(({ enablePerformanceMetrics }) =>
     // @ts-expect-error Reassign
     getCollectionKeys = (0, metrics_1.default)(getCollectionKeys, 'OnyxUtils.getCollectionKeys');
     // @ts-expect-error Reassign
-    addAllSafeEvictionKeysToRecentlyAccessedList = (0, metrics_1.default)(addAllSafeEvictionKeysToRecentlyAccessedList, 'OnyxUtils.addAllSafeEvictionKeysToRecentlyAccessedList');
+    addEvictableKeysToRecentlyAccessedList = (0, metrics_1.default)(OnyxCache_1.default.addEvictableKeysToRecentlyAccessedList, 'OnyxCache.addEvictableKeysToRecentlyAccessedList');
     // @ts-expect-error Reassign
     keysChanged = (0, metrics_1.default)(keysChanged, 'OnyxUtils.keysChanged');
     // @ts-expect-error Reassign

package/dist/types.d.ts

@@ -379,7 +379,7 @@ type InitOptions = {
      * 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.
      */
-    safeEvictionKeys?: OnyxKey[];
+    evictableKeys?: OnyxKey[];
     /**
      * Sets how many recent keys should we try to keep in cache
      * Setting this to 0 would practically mean no cache

package/dist/useOnyx.js

@@ -124,8 +124,8 @@ function useOnyx(key, options, dependencies = []) {
         if ((options === null || options === void 0 ? void 0 : options.canEvict) === undefined || !connectionRef.current) {
             return;
         }
-        if (!OnyxUtils_1.default.isSafeEvictionKey(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({safeEvictionKeys: []}).`);
+        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);

package/dist/withOnyx/index.js

@@ -257,8 +257,8 @@ function default_1(mapOnyxToState, shouldDelayUpdates = false) {
                     }
                     const canEvict = !!Str.result(mapping.canEvict, this.props);
                     const key = Str.result(mapping.key, this.props);
-                    if (!OnyxUtils_1.default.isSafeEvictionKey(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({safeEvictionKeys: []}).`);
+                    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 (canEvict) {
                         OnyxConnectionManager_1.default.removeFromEvictionBlockList(this.activeConnections[key]);

package/package.json

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