react-native-onyx 2.0.21 → 2.0.23

package/dist/utils.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable @typescript-eslint/prefer-for-of */
 Object.defineProperty(exports, "__esModule", { value: true });
 /** Checks whether the given object is an object and not null/undefined. */
 function isEmptyObject(obj) {
@@ -9,8 +10,8 @@ function isEmptyObject(obj) {
  * Checks whether the given value can be merged. It has to be an object, but not an array, RegExp or Date.
  */
 function isMergeableObject(value) {
-    const nonNullObject = value != null ? typeof value === 'object' : false;
-    return nonNullObject && Object.prototype.toString.call(value) !== '[object RegExp]' && Object.prototype.toString.call(value) !== '[object Date]' && !Array.isArray(value);
+    const isNonNullObject = value != null ? typeof value === 'object' : false;
+    return isNonNullObject && Object.prototype.toString.call(value) !== '[object RegExp]' && Object.prototype.toString.call(value) !== '[object Date]' && !Array.isArray(value);
 }
 /**
  * Merges the source object into the target object.
@@ -21,37 +22,49 @@ function isMergeableObject(value) {
  */
 function mergeObject(target, source, shouldRemoveNullObjectValues = true) {
     const destination = {};
+    // First we want to copy over all keys from the target into the destination object,
+    // in case "target" is a mergable object.
+    // If "shouldRemoveNullObjectValues" is true, we want to remove null values from the merged object
+    // and therefore we need to omit keys where either the source or target value is null.
     if (isMergeableObject(target)) {
-        // lodash adds a small overhead so we don't use it here
         const targetKeys = Object.keys(target);
         for (let i = 0; i < targetKeys.length; ++i) {
             const key = targetKeys[i];
             const sourceValue = source === null || source === void 0 ? void 0 : source[key];
             const targetValue = target === null || target === void 0 ? void 0 : target[key];
-            // If shouldRemoveNullObjectValues is true, we want to remove null values from the merged object
+            // If "shouldRemoveNullObjectValues" is true, we want to remove null values from the merged object.
+            // Therefore, if either target or source value is null, we want to prevent the key from being set.
             const isSourceOrTargetNull = targetValue === null || sourceValue === null;
-            const shouldOmitSourceKey = shouldRemoveNullObjectValues && isSourceOrTargetNull;
-            if (!shouldOmitSourceKey) {
+            const shouldOmitTargetKey = shouldRemoveNullObjectValues && isSourceOrTargetNull;
+            if (!shouldOmitTargetKey) {
                 destination[key] = targetValue;
             }
         }
     }
+    // After copying over all keys from the target object, we want to merge the source object into the destination object.
     const sourceKeys = Object.keys(source);
     for (let i = 0; i < sourceKeys.length; ++i) {
         const key = sourceKeys[i];
         const sourceValue = source === null || source === void 0 ? void 0 : source[key];
         const targetValue = target === null || target === void 0 ? void 0 : target[key];
-        // If shouldRemoveNullObjectValues is true, we want to remove null values from the merged object
-        const shouldOmitSourceKey = shouldRemoveNullObjectValues && sourceValue === null;
-        // If we pass undefined as the updated value for a key, we want to generally ignore it
-        const isSourceKeyUndefined = sourceValue === undefined;
-        if (!isSourceKeyUndefined && !shouldOmitSourceKey) {
-            const isSourceKeyMergable = isMergeableObject(sourceValue);
-            if (isSourceKeyMergable && targetValue) {
-                // eslint-disable-next-line no-use-before-define
-                destination[key] = fastMerge(targetValue, sourceValue, shouldRemoveNullObjectValues);
+        // If undefined is passed as the source value for a key, we want to generally ignore it.
+        // If "shouldRemoveNullObjectValues" is set to true and the source value is null,
+        // we don't want to set/merge the source value into the merged object.
+        const shouldIgnoreNullSourceValue = shouldRemoveNullObjectValues && sourceValue === null;
+        const shouldOmitSourceKey = sourceValue === undefined || shouldIgnoreNullSourceValue;
+        if (!shouldOmitSourceKey) {
+            // If the source value is a mergable object, we want to merge it into the target value.
+            // If "shouldRemoveNullObjectValues" is true, "fastMerge" will recursively
+            // remove nested null values from the merged object.
+            // If source value is any other value we need to set the source value it directly.
+            if (isMergeableObject(sourceValue)) {
+                // If the target value is null or undefined, we need to fallback to an empty object,
+                // so that we can still use "fastMerge" to merge the source value,
+                // to ensure that nested null values are removed from the merged object.
+                const targetValueWithFallback = (targetValue !== null && targetValue !== void 0 ? targetValue : {});
+                destination[key] = fastMerge(targetValueWithFallback, sourceValue, shouldRemoveNullObjectValues);
             }
-            else if (!shouldRemoveNullObjectValues || sourceValue !== null) {
+            else {
                 destination[key] = sourceValue;
             }
         }

package/dist/withOnyx.js

@@ -37,6 +37,7 @@ const underscore_1 = __importDefault(require("underscore"));
 const Onyx_1 = __importDefault(require("./Onyx"));
 const Str = __importStar(require("./Str"));
 const utils_1 = __importDefault(require("./utils"));
+const OnyxUtils_1 = __importDefault(require("./OnyxUtils"));
 // This is a list of keys that can exist on a `mapping`, but are not directly related to loading data from Onyx. When the keys of a mapping are looped over to check
 // if a key has changed, it's a good idea to skip looking at these properties since they would have unexpected results.
 const mappingPropertiesToIgnoreChangesTo = ['initialValue', 'allowStaleData'];
@@ -77,7 +78,7 @@ function default_1(mapOnyxToState, shouldDelayUpdates = false) {
                 this.activeConnectionIDs = {};
                 const cachedState = underscore_1.default.reduce(mapOnyxToState, (resultObj, mapping, propertyName) => {
                     const key = Str.result(mapping.key, props);
-                    let value = Onyx_1.default.tryGetCachedValue(key, mapping);
+                    let value = OnyxUtils_1.default.tryGetCachedValue(key, mapping);
                     if (!value && mapping.initialValue) {
                         value = mapping.initialValue;
                     }
@@ -92,7 +93,7 @@ function default_1(mapOnyxToState, shouldDelayUpdates = false) {
                      * In reality, Onyx.merge() will only update the subscriber after all merges have been batched and the previous value is retrieved via a get() (returns a promise).
                      * So, we won't use the cache optimization here as it will lead us to arbitrarily defer various actions in the application code.
                      */
-                    if ((value !== undefined && !Onyx_1.default.hasPendingMergeForKey(key)) || mapping.allowStaleData) {
+                    if ((value !== undefined && !OnyxUtils_1.default.hasPendingMergeForKey(key)) || mapping.allowStaleData) {
                         // eslint-disable-next-line no-param-reassign
                         resultObj[propertyName] = value;
                     }
@@ -246,14 +247,14 @@ function default_1(mapOnyxToState, shouldDelayUpdates = false) {
                     }
                     const canEvict = Str.result(mapping.canEvict, this.props);
                     const key = Str.result(mapping.key, this.props);
-                    if (!Onyx_1.default.isSafeEvictionKey(key)) {
+                    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 (canEvict) {
-                        Onyx_1.default.removeFromEvictionBlockList(key, mapping.connectionID);
+                        OnyxUtils_1.default.removeFromEvictionBlockList(key, mapping.connectionID);
                     }
                     else {
-                        Onyx_1.default.addToEvictionBlockList(key, mapping.connectionID);
+                        OnyxUtils_1.default.addToEvictionBlockList(key, mapping.connectionID);
                     }
                 });
             }

package/package.json

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

package/dist/storage/NativeStorage.d.ts

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

package/dist/storage/WebStorage.d.ts

@@ -1,3 +0,0 @@
-import type StorageProvider from './providers/types';
-declare const webStorage: StorageProvider;
-export default webStorage;

package/dist/storage/WebStorage.js

@@ -1,62 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * This file is here to wrap IDBKeyVal with a layer that provides data-changed events like the ones that exist
- * 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 IDBKeyVal_1 = __importDefault(require("./providers/IDBKeyVal"));
-const SYNC_ONYX = 'SYNC_ONYX';
-/**
- * Raise an event thorough `localStorage` to let other tabs know a value changed
- */
-function raiseStorageSyncEvent(onyxKey) {
-    global.localStorage.setItem(SYNC_ONYX, onyxKey);
-    global.localStorage.removeItem(SYNC_ONYX);
-}
-function raiseStorageSyncManyKeysEvent(onyxKeys) {
-    onyxKeys.forEach((onyxKey) => {
-        raiseStorageSyncEvent(onyxKey);
-    });
-}
-const webStorage = Object.assign(Object.assign({}, IDBKeyVal_1.default), { 
-    /**
-     * @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
-        this.setItem = (key, value) => IDBKeyVal_1.default.setItem(key, value).then(() => raiseStorageSyncEvent(key));
-        this.removeItem = (key) => IDBKeyVal_1.default.removeItem(key).then(() => raiseStorageSyncEvent(key));
-        this.removeItems = (keys) => IDBKeyVal_1.default.removeItems(keys).then(() => raiseStorageSyncManyKeysEvent(keys));
-        this.mergeItem = (key, batchedChanges, modifiedData) => IDBKeyVal_1.default.mergeItem(key, batchedChanges, modifiedData).then(() => raiseStorageSyncEvent(key));
-        // If we just call Storage.clear other tabs will have no idea which keys were available previously
-        // so that they can call keysChanged for them. That's why we iterate over every key and raise a storage sync
-        // event for each one
-        this.clear = () => {
-            let allKeys;
-            // The keys must be retrieved before storage is cleared or else the list of keys would be empty
-            return IDBKeyVal_1.default.getAllKeys()
-                .then((keys) => {
-                allKeys = keys;
-            })
-                .then(() => IDBKeyVal_1.default.clear())
-                .then(() => {
-                // Now that storage is cleared, the storage sync event can happen which is a more atomic action
-                // for other browser tabs
-                allKeys.forEach(raiseStorageSyncEvent);
-            });
-        };
-        // This listener will only be triggered by events coming from other tabs
-        global.addEventListener('storage', (event) => {
-            // Ignore events that don't originate from the SYNC_ONYX logic
-            if (event.key !== SYNC_ONYX || !event.newValue) {
-                return;
-            }
-            const onyxKey = event.newValue;
-            IDBKeyVal_1.default.getItem(onyxKey).then((value) => onStorageKeyChanged(onyxKey, value));
-        });
-    } });
-exports.default = webStorage;

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

@@ -1,2 +0,0 @@
-import NativeStorage from './NativeStorage';
-export default NativeStorage;