react-native-onyx 1.0.29 → 1.0.31

package/API.md

@@ -27,6 +27,11 @@ For this reason, Onyx works more similar to what you might expect from a native
 available async. Since we have code in our main applications that might expect things to work this way it's not safe to change this
 behavior just yet.</p>
 </dd>
+<dt><a href="#notifyCollectionSubscribersOnNextTick">notifyCollectionSubscribersOnNextTick(key, value)</a></dt>
+<dd><p>This method is similar to notifySubscribersOnNextTick but it is built for working specifically with collections
+so that keysChanged() is triggered for the collection and not keyChanged(). If this was not done, then the
+subscriber callbacks receive the data in a different format than they normally expect and it breaks code.</p>
+</dd>
 <dt><a href="#set">set(key, value)</a> ⇒ <code>Promise</code></dt>
 <dd><p>Write a value to our store with the given key</p>
 </dd>
@@ -43,7 +48,7 @@ concatenate. See here: <a href="https://github.com/lodash/lodash/issues/2872">ht
 applied in the order they were called. Note: <code>Onyx.set()</code> calls do not work this way so use caution when mixing
 <code>Onyx.merge()</code> and <code>Onyx.set()</code>.</p>
 </dd>
-<dt><a href="#clear">clear()</a> ⇒ <code>Promise.&lt;void&gt;</code></dt>
+<dt><a href="#clear">clear(keysToPreserve)</a> ⇒ <code>Promise.&lt;void&gt;</code></dt>
 <dd><p>Clear out all the data in the store</p>
 <p>Note that calling Onyx.clear() and then Onyx.set() on a key with a default
 key state may store an unexpected value in Storage.</p>
@@ -62,7 +67,7 @@ value will be saved to storage after the default value.</p>
 <dt><a href="#mergeCollection">mergeCollection(collectionKey, collection)</a> ⇒ <code>Promise</code></dt>
 <dd><p>Merges a collection based on their keys</p>
 </dd>
-<dt><a href="#update">update(data)</a></dt>
+<dt><a href="#update">update(data)</a> ⇒ <code>Promise</code></dt>
 <dd><p>Insert API responses and lifecycle data into Onyx</p>
 </dd>
 <dt><a href="#init">init([options])</a></dt>
@@ -123,7 +128,7 @@ Subscribes a react component's state directly to a store key
 | [mapping.callback] | <code>function</code> | a method that will be called with changed data      This is used by any non-React code to connect to Onyx |
 | [mapping.initWithStoredValues] | <code>Boolean</code> | If set to false, then no data will be prefilled into the  component |
 | [mapping.waitForCollectionCallback] | <code>Boolean</code> | If set to true, it will return the entire collection to the callback as a single object |
-| [mapping.selector] | <code>String</code> \| <code>function</code> | THIS PARAM IS ONLY USED WITH withOnyx(). If included, this will be used to subscribe to a subset of an Onyx key's data. If the selector is a string, the selector is passed to lodashGet on the sourceData. If the selector is a function, the sourceData is passed to the selector and should return the simplified data. Using this setting on `withOnyx` can have very positive performance benefits because the component will only re-render when the subset of data changes. Otherwise, any change of data on any property would normally cause the component to re-render (and that can be expensive from a performance standpoint). |
+| [mapping.selector] | <code>String</code> \| <code>function</code> | THIS PARAM IS ONLY USED WITH withOnyx(). If included, this will be used to subscribe to a subset of an Onyx key's data.       If the selector is a string, the selector is passed to lodashGet on the sourceData. If the selector is a function, the sourceData is passed to the selector and should return the       simplified data. Using this setting on `withOnyx` can have very positive performance benefits because the component will only re-render when the subset of data changes.       Otherwise, any change of data on any property would normally cause the component to re-render (and that can be expensive from a performance standpoint). |
 
 **Example**  
 ```js
@@ -168,6 +173,20 @@ behavior just yet.
 ```js
 notifySubscribersOnNextTick(key, value, subscriber => subscriber.initWithStoredValues === false)
 ```
+<a name="notifyCollectionSubscribersOnNextTick"></a>
+
+## notifyCollectionSubscribersOnNextTick(key, value)
+This method is similar to notifySubscribersOnNextTick but it is built for working specifically with collections
+so that keysChanged() is triggered for the collection and not keyChanged(). If this was not done, then the
+subscriber callbacks receive the data in a different format than they normally expect and it breaks code.
+
+**Kind**: global function  
+
+| Param | Type |
+| --- | --- |
+| key | <code>String</code> | 
+| value | <code>\*</code> | 
+
 <a name="set"></a>
 
 ## set(key, value) ⇒ <code>Promise</code>
@@ -225,7 +244,7 @@ Onyx.merge(ONYXKEYS.POLICY, {name: 'My Workspace'}); // -> {id: 1, name: 'My Wor
 ```
 <a name="clear"></a>
 
-## clear() ⇒ <code>Promise.&lt;void&gt;</code>
+## clear(keysToPreserve) ⇒ <code>Promise.&lt;void&gt;</code>
 Clear out all the data in the store
 
 Note that calling Onyx.clear() and then Onyx.set() on a key with a default
@@ -245,6 +264,11 @@ Storage.setItem() from Onyx.clear() will have already finished and the merged
 value will be saved to storage after the default value.
 
 **Kind**: global function  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| keysToPreserve | <code>Array</code> | is a list of ONYXKEYS that should not be cleared with the rest of the data |
+
 <a name="mergeCollection"></a>
 
 ## mergeCollection(collectionKey, collection) ⇒ <code>Promise</code>
@@ -266,10 +290,11 @@ Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT, {
 ```
 <a name="update"></a>
 
-## update(data)
+## update(data) ⇒ <code>Promise</code>
 Insert API responses and lifecycle data into Onyx
 
 **Kind**: global function  
+**Returns**: <code>Promise</code> - resolves when all operations are complete  
 
 | Param | Type | Description |
 | --- | --- | --- |

package/README.md

@@ -335,6 +335,6 @@ To quickly test small changes you can directly go to `node_modules/react-native-
 To continuously work on Onyx we have to set up a task that copies content to parent project's `node_modules/react-native-onyx`:
 1. Work on Onyx feature or a fix
 2. Save files
-3. Optional: run `npm build` (if you're working or want to test on a non react-native project)
+3. Optional: run `npm run build` (if you're working or want to test on a non react-native project)
    - `npm link` would actually work outside of `react-native` and it can be used to link Onyx locally for a web only project
 4. Copy Onyx to consumer project's `node_modules/react-native-onyx`

package/dist/web.development.js

@@ -1152,7 +1152,10 @@ function getCollectionDataAndSendAsObject(matchingKeys, mapping) {
  * @param {Boolean} [mapping.initWithStoredValues] If set to false, then no data will be prefilled into the
  *  component
  * @param {Boolean} [mapping.waitForCollectionCallback] If set to true, it will return the entire collection to the callback as a single object
- * @param {String|Function} [mapping.selector] THIS PARAM IS ONLY USED WITH withOnyx(). If included, this will be used to subscribe to a subset of an Onyx key's data. If the selector is a string, the selector is passed to lodashGet on the sourceData. If the selector is a function, the sourceData is passed to the selector and should return the simplified data. Using this setting on `withOnyx` can have very positive performance benefits because the component will only re-render when the subset of data changes. Otherwise, any change of data on any property would normally cause the component to re-render (and that can be expensive from a performance standpoint).
+ * @param {String|Function} [mapping.selector] THIS PARAM IS ONLY USED WITH withOnyx(). If included, this will be used to subscribe to a subset of an Onyx key's data.
+ *       If the selector is a string, the selector is passed to lodashGet on the sourceData. If the selector is a function, the sourceData is passed to the selector and should return the
+ *       simplified data. Using this setting on `withOnyx` can have very positive performance benefits because the component will only re-render when the subset of data changes.
+ *       Otherwise, any change of data on any property would normally cause the component to re-render (and that can be expensive from a performance standpoint).
  * @returns {Number} an ID to use when calling disconnect
  */
 function connect(mapping) {
@@ -1266,6 +1269,19 @@ function notifySubscribersOnNextTick(key, value, canUpdateSubscriber) {
   Promise.resolve().then(function () {return keyChanged(key, value, canUpdateSubscriber);});
 }
 
+/**
+ * This method is similar to notifySubscribersOnNextTick but it is built for working specifically with collections
+ * so that keysChanged() is triggered for the collection and not keyChanged(). If this was not done, then the
+ * subscriber callbacks receive the data in a different format than they normally expect and it breaks code.
+ *
+ * @param {String} key
+ * @param {*} value
+ */
+// eslint-disable-next-line rulesdir/no-negated-variables
+function notifyCollectionSubscribersOnNextTick(key, value) {
+  Promise.resolve().then(function () {return keysChanged(key, value);});
+}
+
 /**
  * Remove a key from Onyx and update the subscribers
  *
@@ -1516,17 +1532,68 @@ function initializeWithDefaultKeyStates() {
  * Storage.setItem() from Onyx.clear() will have already finished and the merged
  * value will be saved to storage after the default value.
  *
+ * @param {Array} keysToPreserve is a list of ONYXKEYS that should not be cleared with the rest of the data
  * @returns {Promise<void>}
  */
-function clear() {
+function clear() {var keysToPreserve = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   return getAllKeys().
   then(function (keys) {
-    _underscore.default.each(keys, function (key) {
-      var resetValue = (0, _get.default)(defaultKeyStates, key, null);
-      _OnyxCache.default.set(key, resetValue);
-      notifySubscribersOnNextTick(key, resetValue);
+    var keyValuesToReset = [];
+    var defaultKeys = _underscore.default.keys(defaultKeyStates);
+
+    // The only keys that should not be cleared are:
+    // 1. Anything specifically passed in keysToPreserve (because some keys like language preferences, offline
+    //      status, or activeClients need to remain in Onyx even when signed out)
+    // 2. Any keys with a default state (because they need to remain in Onyx as their default, and setting them
+    //      to null would cause unknown behavior)
+    var keysToClear = _underscore.default.difference(keys, keysToPreserve, defaultKeys);
+    keyValuesToReset.push.apply(keyValuesToReset, (0, _toConsumableArray2.default)(_underscore.default.map(keysToClear, function (key) {return [key, null];})));
+
+    // Remove any keysToPreserve from the defaultKeyStates because if they are passed in it has been explicitly
+    // called out to preserve those values instead of resetting them back
+    // to the default.
+    var defaultKeyValuePairs = _underscore.default.pairs(_underscore.default.omit.apply(_underscore.default, [defaultKeyStates].concat((0, _toConsumableArray2.default)(keysToPreserve))));
+
+    // Add the default key value pairs to the keyValuesToReset so that they get set back to their default values
+    // when we clear Onyx
+    keyValuesToReset.push.apply(keyValuesToReset, (0, _toConsumableArray2.default)(defaultKeyValuePairs));
+
+    // We now have all the key/values that need to be reset, but we're not done yet!
+    // There will be two groups of key/values and they each need to be updated a little bit differently.
+    // Collection keys need to be notified differently than non collection keys
+    var keyValuesToResetAsCollection = {};
+    var keyValuesToResetIndividually = {};
+
+    // Make sure that we also reset the cache values before clearing the values from storage.
+    // We do this before clearing Storage so that any call to clear() followed by merge() on a key with a
+    // default state results in the merged value getting saved, since the update from the merge() call would
+    // happen on the tick after the update from this clear()
+    _underscore.default.each(keyValuesToReset, function (keyValue) {
+      var key = keyValue[0];
+      var value = keyValue[1];
+      _OnyxCache.default.set(key, value);
+
+      var collectionKey = key.substring(0, key.indexOf('_') + 1);
+      if (collectionKey) {
+        if (!keyValuesToResetAsCollection[collectionKey]) {
+          keyValuesToResetAsCollection[collectionKey] = {};
+        }
+        keyValuesToResetAsCollection[collectionKey][key] = value;
+        return;
+      }
+
+      keyValuesToResetIndividually[key] = value;
     });
-    return _storage.default.clear();
+
+    // Notify the subscribers for each key/value group so they can receive the new values
+    _underscore.default.each(keyValuesToResetIndividually, function (value, key) {
+      notifySubscribersOnNextTick(key, value);
+    });
+    _underscore.default.each(keyValuesToResetAsCollection, function (value, key) {
+      notifyCollectionSubscribersOnNextTick(key, value);
+    });
+
+    return _storage.default.multiSet(keyValuesToReset);
   });
 }