react-native-onyx 2.0.3 → 2.0.5

package/dist/Onyx.js

@@ -486,7 +486,7 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
                     const data = cachedCollection[subscriber.key];
                     const previousData = prevState[subscriber.statePropertyName];
                     // Avoids triggering unnecessary re-renders when feeding empty objects
-                    if (utils_1.default.areObjectsEmpty(data, previousData)) {
+                    if (utils_1.default.isEmptyObject(data) && utils_1.default.isEmptyObject(previousData)) {
                         return null;
                     }
                     if (data === previousData) {
@@ -510,11 +510,12 @@ function keysChanged(collectionKey, partialCollection, notifyRegularSubscibers =
  * @private
  * @param {String} key
  * @param {*} data
+ * @param {*} prevData
  * @param {Function} [canUpdateSubscriber] only subscribers that pass this truth test will be updated
  * @param {boolean} [notifyRegularSubscibers=true]
  * @param {boolean} [notifyWithOnyxSubscibers=true]
  */
-function keyChanged(key, data, canUpdateSubscriber, notifyRegularSubscibers = true, notifyWithOnyxSubscibers = true) {
+function keyChanged(key, data, prevData, canUpdateSubscriber = () => true, notifyRegularSubscibers = true, notifyWithOnyxSubscibers = true) {
     // Add or remove this key from the recentlyAccessedKeys lists
     if (!underscore_1.default.isNull(data)) {
         addLastAccessedKey(key);
@@ -528,7 +529,7 @@ function keyChanged(key, data, canUpdateSubscriber, notifyRegularSubscibers = tr
     const stateMappingKeys = underscore_1.default.keys(callbackToStateMapping);
     for (let i = 0; i < stateMappingKeys.length; i++) {
         const subscriber = callbackToStateMapping[stateMappingKeys[i]];
-        if (!subscriber || !isKeyMatch(subscriber.key, key) || (underscore_1.default.isFunction(canUpdateSubscriber) && !canUpdateSubscriber(subscriber))) {
+        if (!subscriber || !isKeyMatch(subscriber.key, key) || !canUpdateSubscriber(subscriber)) {
             continue;
         }
         // Subscriber is a regular call to connect() and provided a callback
@@ -556,13 +557,13 @@ function keyChanged(key, data, canUpdateSubscriber, notifyRegularSubscibers = tr
                 // returned by the selector and only when the selected data has changed.
                 if (subscriber.selector) {
                     subscriber.withOnyxInstance.setStateProxy((prevState) => {
-                        const prevData = prevState[subscriber.statePropertyName];
-                        const newData = {
+                        const prevWithOnyxData = prevState[subscriber.statePropertyName];
+                        const newWithOnyxData = {
                             [key]: getSubsetOfData(data, subscriber.selector, subscriber.withOnyxInstance.state),
                         };
-                        const prevDataWithNewData = Object.assign(Object.assign({}, prevData), newData);
-                        if (!(0, fast_equals_1.deepEqual)(prevData, prevDataWithNewData)) {
-                            PerformanceUtils.logSetStateCall(subscriber, prevData, newData, 'keyChanged', key);
+                        const prevDataWithNewData = Object.assign(Object.assign({}, prevWithOnyxData), newWithOnyxData);
+                        if (!(0, fast_equals_1.deepEqual)(prevWithOnyxData, prevDataWithNewData)) {
+                            PerformanceUtils.logSetStateCall(subscriber, prevWithOnyxData, newWithOnyxData, 'keyChanged', key);
                             return {
                                 [subscriber.statePropertyName]: prevDataWithNewData,
                             };
@@ -584,8 +585,8 @@ function keyChanged(key, data, canUpdateSubscriber, notifyRegularSubscibers = tr
             // If the subscriber has a selector, then the component's state must only be updated with the data
             // returned by the selector and only if the selected data has changed.
             if (subscriber.selector) {
-                subscriber.withOnyxInstance.setStateProxy((prevState) => {
-                    const previousValue = getSubsetOfData(prevState[subscriber.statePropertyName], subscriber.selector, subscriber.withOnyxInstance.state);
+                subscriber.withOnyxInstance.setStateProxy(() => {
+                    const previousValue = getSubsetOfData(prevData, subscriber.selector, subscriber.withOnyxInstance.state);
                     const newValue = getSubsetOfData(data, subscriber.selector, subscriber.withOnyxInstance.state);
                     if (!(0, fast_equals_1.deepEqual)(previousValue, newValue)) {
                         return {
@@ -598,15 +599,15 @@ function keyChanged(key, data, canUpdateSubscriber, notifyRegularSubscibers = tr
             }
             // If we did not match on a collection key then we just set the new data to the state property
             subscriber.withOnyxInstance.setStateProxy((prevState) => {
-                const previousData = prevState[subscriber.statePropertyName];
+                const prevWithOnyxData = prevState[subscriber.statePropertyName];
                 // Avoids triggering unnecessary re-renders when feeding empty objects
-                if (utils_1.default.areObjectsEmpty(data, previousData)) {
+                if (utils_1.default.isEmptyObject(data) && utils_1.default.isEmptyObject(prevWithOnyxData)) {
                     return null;
                 }
-                if (previousData === data) {
+                if (prevWithOnyxData === data) {
                     return null;
                 }
-                PerformanceUtils.logSetStateCall(subscriber, previousData, data, 'keyChanged', key);
+                PerformanceUtils.logSetStateCall(subscriber, prevData, data, 'keyChanged', key);
                 return {
                     [subscriber.statePropertyName]: data,
                 };
@@ -829,12 +830,13 @@ function disconnect(connectionID, keyToRemoveFromEvictionBlocklist) {
  *
  * @param {String} key
  * @param {*} value
+ * @param {*} prevValue
  * @param {Function} [canUpdateSubscriber] only subscribers that pass this truth test will be updated
  * @returns {Promise}
  */
-function scheduleSubscriberUpdate(key, value, canUpdateSubscriber) {
-    const promise = Promise.resolve().then(() => keyChanged(key, value, canUpdateSubscriber, true, false));
-    batchUpdates(() => keyChanged(key, value, canUpdateSubscriber, false, true));
+function scheduleSubscriberUpdate(key, value, prevValue, canUpdateSubscriber = () => true) {
+    const promise = Promise.resolve().then(() => keyChanged(key, value, prevValue, canUpdateSubscriber, true, false));
+    batchUpdates(() => keyChanged(key, value, prevValue, canUpdateSubscriber, false, true));
     return Promise.all([maybeFlushBatchUpdates(), promise]);
 }
 /**
@@ -859,8 +861,9 @@ function scheduleNotifyCollectionSubscribers(key, value) {
  * @return {Promise}
  */
 function remove(key) {
+    const prevValue = OnyxCache_1.default.getValue(key, false);
     OnyxCache_1.default.drop(key);
-    scheduleSubscriberUpdate(key, null);
+    scheduleSubscriberUpdate(key, null, prevValue);
     return storage_1.default.removeItem(key);
 }
 /**
@@ -920,6 +923,7 @@ function evictStorageAndRetry(error, onyxMethod, ...args) {
 function broadcastUpdate(key, value, method, hasChanged, wasRemoved = false) {
     // Logging properties only since values could be sensitive things we don't want to log
     Logger.logInfo(`${method}() called for key: ${key}${underscore_1.default.isObject(value) ? ` properties: ${underscore_1.default.keys(value).join(',')}` : ''}`);
+    const prevValue = OnyxCache_1.default.getValue(key, false);
     // Update subscribers if the cached value has changed, or when the subscriber specifically requires
     // all updates regardless of value changes (indicated by initWithStoredValues set to false).
     if (hasChanged && !wasRemoved) {
@@ -928,7 +932,7 @@ function broadcastUpdate(key, value, method, hasChanged, wasRemoved = false) {
     else {
         OnyxCache_1.default.addToAccessedKeys(key);
     }
-    return scheduleSubscriberUpdate(key, value, (subscriber) => hasChanged || subscriber.initWithStoredValues === false);
+    return scheduleSubscriberUpdate(key, value, prevValue, (subscriber) => hasChanged || subscriber.initWithStoredValues === false);
 }
 /**
  * @param {String} key
@@ -1011,9 +1015,10 @@ function prepareKeyValuePairsForStorage(data) {
 function multiSet(data) {
     const keyValuePairs = prepareKeyValuePairsForStorage(data);
     const updatePromises = underscore_1.default.map(keyValuePairs, ([key, value]) => {
+        const prevValue = OnyxCache_1.default.getValue(key, false);
         // Update cache and optimistically inform subscribers on the next tick
         OnyxCache_1.default.set(key, value);
-        return scheduleSubscriberUpdate(key, value);
+        return scheduleSubscriberUpdate(key, value, prevValue);
     });
     return storage_1.default.multiSet(keyValuePairs)
         .catch((error) => evictStorageAndRetry(error, multiSet, data))
@@ -1130,10 +1135,10 @@ function merge(key, changes) {
  */
 function initializeWithDefaultKeyStates() {
     return storage_1.default.multiGet(underscore_1.default.keys(defaultKeyStates)).then((pairs) => {
-        const asObject = underscore_1.default.object(pairs);
-        const merged = utils_1.default.fastMerge(asObject, defaultKeyStates);
+        const existingDataAsObject = underscore_1.default.object(pairs);
+        const merged = utils_1.default.fastMerge(existingDataAsObject, defaultKeyStates);
         OnyxCache_1.default.merge(merged);
-        underscore_1.default.each(merged, (val, key) => keyChanged(key, val));
+        underscore_1.default.each(merged, (val, key) => keyChanged(key, val, existingDataAsObject));
     });
 }
 /**
@@ -1201,7 +1206,7 @@ function clear(keysToPreserve = []) {
         const updatePromises = [];
         // Notify the subscribers for each key/value group so they can receive the new values
         underscore_1.default.each(keyValuesToResetIndividually, (value, key) => {
-            updatePromises.push(scheduleSubscriberUpdate(key, value));
+            updatePromises.push(scheduleSubscriberUpdate(key, value, OnyxCache_1.default.getValue(key, false)));
         });
         underscore_1.default.each(keyValuesToResetAsCollection, (value, key) => {
             updatePromises.push(scheduleNotifyCollectionSubscribers(key, value));
@@ -1401,8 +1406,9 @@ function init({ keys = {}, initialKeyStates = {}, safeEvictionKeys = [], maxCach
     Promise.all([addAllSafeEvictionKeysToRecentlyAccessedList(), initializeWithDefaultKeyStates()]).then(deferredInitTask.resolve);
     if (shouldSyncMultipleInstances && underscore_1.default.isFunction(storage_1.default.keepInstancesSync)) {
         storage_1.default.keepInstancesSync((key, value) => {
+            const prevValue = OnyxCache_1.default.getValue(key, false);
             OnyxCache_1.default.set(key, value);
-            keyChanged(key, value);
+            keyChanged(key, value, prevValue);
         });
     }
 }

package/dist/OnyxCache.d.ts

@@ -1,121 +1,75 @@
-export default instance;
-declare const instance: OnyxCache;
+import type { Key, Value } from './storage/providers/types';
+type StorageMap = Record<Key, Value>;
 /**
  * In memory cache providing data by reference
  * Encapsulates Onyx cache related functionality
  */
 declare class OnyxCache {
-    /**
-     * @private
-     * Cache of all the storage keys available in persistent storage
-     * @type {Set<string>}
-     */
+    /** Cache of all the storage keys available in persistent storage */
     private storageKeys;
-    /**
-     * @private
-     * Unique list of keys maintained in access order (most recent at the end)
-     * @type {Set<string>}
-     */
+    /** Unique list of keys maintained in access order (most recent at the end) */
     private recentKeys;
-    /**
-     * @private
-     * A map of cached values
-     * @type {Record<string, *>}
-     */
+    /** A map of cached values */
     private storageMap;
     /**
-     * @private
      * Captured pending tasks for already running storage methods
      * Using a map yields better performance on operations such a delete
-     * https://www.zhenghao.io/posts/object-vs-map
-     * @type {Map<string, Promise>}
      */
     private pendingPromises;
-    /**
-     * Get all the storage keys
-     * @returns {string[]}
-     */
-    getAllKeys(): string[];
+    /** Maximum size of the keys store din cache */
+    private maxRecentKeysSize;
+    constructor();
+    /** Get all the storage keys */
+    getAllKeys(): Key[];
     /**
      * Get a cached value from storage
-     * @param {string} key
-     * @returns {*}
+     * @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.
      */
-    getValue(key: string): any;
-    /**
-     * Check whether cache has data for the given key
-     * @param {string} key
-     * @returns {boolean}
-     */
-    hasCacheForKey(key: string): boolean;
-    /**
-     * Saves a key in the storage keys list
+    getValue(key: Key, shouldReindexCache?: boolean): Value;
+    /** Check whether cache has data for the given key */
+    hasCacheForKey(key: Key): boolean;
+    /** Saves a key in the storage keys list
      * Serves to keep the result of `getAllKeys` up to date
-     * @param {string} key
      */
-    addKey(key: string): void;
+    addKey(key: Key): void;
     /**
      * Set's a key value in cache
      * Adds the key to the storage keys list as well
-     * @param {string} key
-     * @param {*} value
-     * @returns {*} value - returns the cache value
      */
-    set(key: string, value: any): any;
-    /**
-     * Forget the cached value for the given key
-     * @param {string} key
-     */
-    drop(key: string): void;
+    set(key: Key, value: Value): Value;
+    /** Forget the cached value for the given key */
+    drop(key: Key): void;
     /**
      * Deep merge data to cache, any non existing keys will be created
-     * @param {Record<string, *>} data - a map of (cache) key - values
+     * @param data - a map of (cache) key - values
      */
-    merge(data: Record<string, any>): void;
+    merge(data: StorageMap): void;
     /**
      * Check whether the given task is already running
-     * @param {string} taskName - unique name given for the task
-     * @returns {*}
+     * @param taskName - unique name given for the task
      */
-    hasPendingTask(taskName: string): any;
+    hasPendingTask(taskName: string): boolean;
     /**
      * Use this method to prevent concurrent calls for the same thing
      * Instead of calling the same task again use the existing promise
      * provided from this function
-     * @template T
-     * @param {string} taskName - unique name given for the task
-     * @returns {Promise<T>}
+     * @param taskName - unique name given for the task
      */
-    getTaskPromise<T>(taskName: string): Promise<T>;
+    getTaskPromise(taskName: string): Promise<unknown> | undefined;
     /**
      * Capture a promise for a given task so other caller can
      * hook up to the promise if it's still pending
-     * @template T
-     * @param {string} taskName - unique name for the task
-     * @param {Promise<T>} promise
-     * @returns {Promise<T>}
-     */
-    captureTask<T_1>(taskName: string, promise: Promise<T_1>): Promise<T_1>;
-    /**
-     * @private
-     * Adds a key to the top of the recently accessed keys
-     * @param {string} key
+     * @param taskName - unique name for the task
      */
+    captureTask(taskName: string, promise: Promise<unknown>): Promise<unknown>;
+    /** Adds a key to the top of the recently accessed keys */
     private addToAccessedKeys;
-    /**
-     * Remove keys that don't fall into the range of recently used keys
-     */
+    /** Remove keys that don't fall into the range of recently used keys */
     removeLeastRecentlyUsedKeys(): void;
-    /**
-     * Set the recent keys list size
-     * @param {number} limit
-     */
+    /** Set the recent keys list size */
     setRecentKeysLimit(limit: number): void;
-    maxRecentKeysSize: number | undefined;
-    /**
-     * @param {String} key
-     * @param {*} value
-     * @returns {Boolean}
-     */
-    hasValueChanged(key: string, value: any): boolean;
+    /** Check if the value has changed */
+    hasValueChanged(key: Key, value: Value): boolean;
 }
+declare const instance: OnyxCache;
+export default instance;

package/dist/OnyxCache.js

@@ -3,73 +3,44 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const underscore_1 = __importDefault(require("underscore"));
 const fast_equals_1 = require("fast-equals");
+const bindAll_1 = __importDefault(require("lodash/bindAll"));
 const utils_1 = __importDefault(require("./utils"));
-const isDefined = underscore_1.default.negate(underscore_1.default.isUndefined);
 /**
  * In memory cache providing data by reference
  * Encapsulates Onyx cache related functionality
  */
 class OnyxCache {
     constructor() {
-        /**
-         * @private
-         * Cache of all the storage keys available in persistent storage
-         * @type {Set<string>}
-         */
+        /** Maximum size of the keys store din cache */
+        this.maxRecentKeysSize = 0;
         this.storageKeys = new Set();
-        /**
-         * @private
-         * Unique list of keys maintained in access order (most recent at the end)
-         * @type {Set<string>}
-         */
         this.recentKeys = new Set();
-        /**
-         * @private
-         * A map of cached values
-         * @type {Record<string, *>}
-         */
         this.storageMap = {};
-        /**
-         * @private
-         * Captured pending tasks for already running storage methods
-         * Using a map yields better performance on operations such a delete
-         * https://www.zhenghao.io/posts/object-vs-map
-         * @type {Map<string, Promise>}
-         */
         this.pendingPromises = new Map();
         // bind all public methods to prevent problems with `this`
-        underscore_1.default.bindAll(this, 'getAllKeys', 'getValue', 'hasCacheForKey', 'addKey', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit');
+        (0, bindAll_1.default)(this, 'getAllKeys', 'getValue', 'hasCacheForKey', 'addKey', 'set', 'drop', 'merge', 'hasPendingTask', 'getTaskPromise', 'captureTask', 'removeLeastRecentlyUsedKeys', 'setRecentKeysLimit');
     }
-    /**
-     * Get all the storage keys
-     * @returns {string[]}
-     */
+    /** Get all the storage keys */
     getAllKeys() {
         return Array.from(this.storageKeys);
     }
     /**
      * Get a cached value from storage
-     * @param {string} key
-     * @returns {*}
+     * @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.
      */
-    getValue(key) {
-        this.addToAccessedKeys(key);
+    getValue(key, shouldReindexCache = true) {
+        if (shouldReindexCache) {
+            this.addToAccessedKeys(key);
+        }
         return this.storageMap[key];
     }
-    /**
-     * Check whether cache has data for the given key
-     * @param {string} key
-     * @returns {boolean}
-     */
+    /** Check whether cache has data for the given key */
     hasCacheForKey(key) {
-        return isDefined(this.storageMap[key]);
+        return this.storageMap[key] !== undefined;
     }
-    /**
-     * Saves a key in the storage keys list
+    /** Saves a key in the storage keys list
      * Serves to keep the result of `getAllKeys` up to date
-     * @param {string} key
      */
     addKey(key) {
         this.storageKeys.add(key);
@@ -77,9 +48,6 @@ class OnyxCache {
     /**
      * Set's a key value in cache
      * Adds the key to the storage keys list as well
-     * @param {string} key
-     * @param {*} value
-     * @returns {*} value - returns the cache value
      */
     set(key, value) {
         this.addKey(key);
@@ -87,10 +55,7 @@ class OnyxCache {
         this.storageMap[key] = value;
         return value;
     }
-    /**
-     * Forget the cached value for the given key
-     * @param {string} key
-     */
+    /** Forget the cached value for the given key */
     drop(key) {
         delete this.storageMap[key];
         this.storageKeys.delete(key);
@@ -98,35 +63,30 @@ class OnyxCache {
     }
     /**
      * Deep merge data to cache, any non existing keys will be created
-     * @param {Record<string, *>} data - a map of (cache) key - values
+     * @param data - a map of (cache) key - values
      */
     merge(data) {
-        if (!underscore_1.default.isObject(data) || underscore_1.default.isArray(data)) {
+        if (typeof data !== 'object' || Array.isArray(data)) {
             throw new Error('data passed to cache.merge() must be an Object of onyx key/value pairs');
         }
-        // lodash adds a small overhead so we don't use it here
-        // eslint-disable-next-line prefer-object-spread, rulesdir/prefer-underscore-method
         this.storageMap = Object.assign({}, utils_1.default.fastMerge(this.storageMap, data, false));
         const storageKeys = this.getAllKeys();
-        const mergedKeys = underscore_1.default.keys(data);
+        const mergedKeys = Object.keys(data);
         this.storageKeys = new Set([...storageKeys, ...mergedKeys]);
-        underscore_1.default.each(mergedKeys, (key) => this.addToAccessedKeys(key));
+        mergedKeys.forEach((key) => this.addToAccessedKeys(key));
     }
     /**
      * Check whether the given task is already running
-     * @param {string} taskName - unique name given for the task
-     * @returns {*}
+     * @param taskName - unique name given for the task
      */
     hasPendingTask(taskName) {
-        return isDefined(this.pendingPromises.get(taskName));
+        return this.pendingPromises.get(taskName) !== undefined;
     }
     /**
      * Use this method to prevent concurrent calls for the same thing
      * Instead of calling the same task again use the existing promise
      * provided from this function
-     * @template T
-     * @param {string} taskName - unique name given for the task
-     * @returns {Promise<T>}
+     * @param taskName - unique name given for the task
      */
     getTaskPromise(taskName) {
         return this.pendingPromises.get(taskName);
@@ -134,10 +94,7 @@ class OnyxCache {
     /**
      * Capture a promise for a given task so other caller can
      * hook up to the promise if it's still pending
-     * @template T
-     * @param {string} taskName - unique name for the task
-     * @param {Promise<T>} promise
-     * @returns {Promise<T>}
+     * @param taskName - unique name for the task
      */
     captureTask(taskName, promise) {
         const returnPromise = promise.finally(() => {
@@ -146,19 +103,12 @@ class OnyxCache {
         this.pendingPromises.set(taskName, returnPromise);
         return returnPromise;
     }
-    /**
-     * @private
-     * Adds a key to the top of the recently accessed keys
-     * @param {string} key
-     */
+    /** Adds a key to the top of the recently accessed keys */
     addToAccessedKeys(key) {
-        // Removing and re-adding a key ensures it's at the end of the list
         this.recentKeys.delete(key);
         this.recentKeys.add(key);
     }
-    /**
-     * Remove keys that don't fall into the range of recently used keys
-     */
+    /** Remove keys that don't fall into the range of recently used keys */
     removeLeastRecentlyUsedKeys() {
         let numKeysToRemove = this.recentKeys.size - this.maxRecentKeysSize;
         if (numKeysToRemove <= 0) {
@@ -171,23 +121,17 @@ class OnyxCache {
             temp.push(value);
             numKeysToRemove--;
         }
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
         for (let i = 0; i < temp.length; ++i) {
             delete this.storageMap[temp[i]];
             this.recentKeys.delete(temp[i]);
         }
     }
-    /**
-     * Set the recent keys list size
-     * @param {number} limit
-     */
+    /** Set the recent keys list size */
     setRecentKeysLimit(limit) {
         this.maxRecentKeysSize = limit;
     }
-    /**
-     * @param {String} key
-     * @param {*} value
-     * @returns {Boolean}
-     */
+    /** Check if the value has changed */
     hasValueChanged(key, value) {
         return !(0, fast_equals_1.deepEqual)(this.storageMap[key], value);
     }

package/dist/storage/NativeStorage.d.ts

@@ -1,2 +1,2 @@
-export default SQLiteStorage;
 import SQLiteStorage from './providers/SQLiteStorage';
+export default SQLiteStorage;

package/dist/storage/WebStorage.d.ts

@@ -1,19 +1,3 @@
+import type StorageProvider from './providers/types';
+declare const webStorage: StorageProvider;
 export default webStorage;
-declare const webStorage: {
-    /**
-     * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
-     */
-    keepInstancesSync(onStorageKeyChanged: Function): void;
-    setItem: (key: string, value: any) => Promise<void>;
-    multiGet: (keysParam: string[]) => Promise<[key, value][]>;
-    multiMerge: (pairs: [key, value][]) => Promise<void>;
-    mergeItem(key: string, _changes: any, modifiedData: any): Promise<void>;
-    multiSet: (pairs: [key, value][]) => Promise<void>;
-    clear: () => Promise<void>;
-    setMemoryOnlyKeys: () => void;
-    getAllKeys: () => Promise<string[]>;
-    getItem: (key: string) => Promise<any>;
-    removeItem: (key: string) => Promise<void>;
-    removeItems: (keysParam: any[]) => Promise<any>;
-    getDatabaseSize(): Promise<number>;
-};

package/dist/storage/WebStorage.js

@@ -8,25 +8,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * when using LocalStorage APIs in the browser. These events are great because multiple tabs can listen for when
  * data changes and then stay up-to-date with everything happening in Onyx.
  */
-const underscore_1 = __importDefault(require("underscore"));
 const IDBKeyVal_1 = __importDefault(require("./providers/IDBKeyVal"));
 const SYNC_ONYX = 'SYNC_ONYX';
 /**
  * Raise an event thorough `localStorage` to let other tabs know a value changed
- * @param {String} onyxKey
  */
 function raiseStorageSyncEvent(onyxKey) {
     global.localStorage.setItem(SYNC_ONYX, onyxKey);
-    global.localStorage.removeItem(SYNC_ONYX, onyxKey);
+    global.localStorage.removeItem(SYNC_ONYX);
 }
 function raiseStorageSyncManyKeysEvent(onyxKeys) {
-    underscore_1.default.each(onyxKeys, (onyxKey) => {
+    onyxKeys.forEach((onyxKey) => {
         raiseStorageSyncEvent(onyxKey);
     });
 }
 const webStorage = Object.assign(Object.assign({}, IDBKeyVal_1.default), { 
     /**
-     * @param {Function} onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
+     * @param onStorageKeyChanged Storage synchronization mechanism keeping all opened tabs in sync
      */
     keepInstancesSync(onStorageKeyChanged) {
         // Override set, remove and clear to raise storage events that we intercept in other tabs
@@ -48,7 +46,7 @@ const webStorage = Object.assign(Object.assign({}, IDBKeyVal_1.default), {
                 .then(() => {
                 // Now that storage is cleared, the storage sync event can happen which is a more atomic action
                 // for other browser tabs
-                underscore_1.default.each(allKeys, raiseStorageSyncEvent);
+                allKeys.forEach(raiseStorageSyncEvent);
             });
         };
         // This listener will only be triggered by events coming from other tabs

package/dist/storage/__mocks__/index.d.ts

@@ -1,23 +1,23 @@
-export default idbKeyvalMockSpy;
-declare namespace idbKeyvalMockSpy {
-    export { set as idbKeyvalSet };
-    export let setItem: jest.Mock<Promise<any>, [key?: any, value?: any]>;
-    export let getItem: jest.Mock<Promise<any>, [key?: any]>;
-    export let removeItem: jest.Mock<Promise<void>, [key?: any]>;
-    export let removeItems: jest.Mock<Promise<void>, [keys?: any]>;
-    export let clear: jest.Mock<Promise<void>, []>;
-    export let getAllKeys: jest.Mock<Promise<any>, []>;
-    export let config: jest.Mock<void, []>;
-    export let multiGet: jest.Mock<Promise<any>, [keys?: any]>;
-    export let multiSet: jest.Mock<Promise<any>, [pairs?: any]>;
-    export let multiMerge: jest.Mock<Promise<{}>, [pairs?: any]>;
-    export let mergeItem: jest.Mock<Promise<any>, [key?: any, _changes?: any, modifiedData?: any]>;
-    export let getStorageMap: jest.Mock<{}, []>;
-    export let setInitialMockData: jest.Mock<void, [data?: any]>;
-    export let getDatabaseSize: jest.Mock<Promise<{
-        bytesRemaining: number;
+/// <reference types="jest" />
+import type { KeyValuePairList } from '../providers/types';
+declare const idbKeyvalMockSpy: {
+    idbKeyvalSet: jest.Mock<Promise<any>, [key: any, value: any]>;
+    setItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: string, value: IDBValidKey]>;
+    getItem: jest.Mock<Promise<IDBValidKey | null>, [key: string]>;
+    removeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [key: string]>;
+    removeItems: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, [keys: import("../providers/types").KeyList]>;
+    clear: jest.Mock<Promise<void | import("react-native-quick-sqlite").QueryResult>, []>;
+    getAllKeys: jest.Mock<Promise<import("../providers/types").KeyList>, []>;
+    multiGet: jest.Mock<Promise<KeyValuePairList>, [keys: import("../providers/types").KeyList]>;
+    multiSet: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [pairs: KeyValuePairList]>;
+    multiMerge: jest.Mock<Promise<import("react-native-quick-sqlite").BatchQueryResult | IDBValidKey[]>, [pairs: KeyValuePairList]>;
+    mergeItem: jest.Mock<Promise<void | import("react-native-quick-sqlite").BatchQueryResult>, [key: string, changes: IDBValidKey, modifiedData: IDBValidKey]>;
+    getStorageMap: jest.Mock<Record<string, IDBValidKey>, []>;
+    setInitialMockData: jest.Mock<void, [data: any]>;
+    getDatabaseSize: jest.Mock<Promise<{
         bytesUsed: number;
+        bytesRemaining: number;
     }>, []>;
-    export let setMemoryOnlyKeys: jest.Mock<void, []>;
-}
-declare const set: jest.Mock<Promise<any>, [key?: any, value?: any]>;
+    setMemoryOnlyKeys: jest.Mock<void, []>;
+};
+export default idbKeyvalMockSpy;