[TS migration] Migrate Onyx public methods to TS

lib/Onyx.ts

@@ -79,11 +79,16 @@ function init({
  * @param [mapping.initWithStoredValues] If set to false, then no data will be prefilled into the
  *  component
  * @param [mapping.waitForCollectionCallback] If set to true, it will return the entire collection to the callback as a single object
+ * @param [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.
+ *       The sourceData and withOnyx state are 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 [mapping.initialValue] THIS PARAM IS ONLY USED WITH withOnyx().
+ * If included, this will be passed to the component so that something can be rendered while data is being fetched from the DB.
+ * Note that it will not cause the component to have the loading prop set to true. |
  * @returns an ID to use when calling disconnect
  */
-function connect<TKey extends OnyxKey>(options: ConnectOptions<TKey>): number {
-    const mapping = options as unknown as Mapping<OnyxKey>;
-
+function connect<TKey extends OnyxKey>(mapping: ConnectOptions<TKey>): number {
     const connectionID = lastConnectionID++;
     OnyxUtils.callbackToStateMapping[connectionID] = mapping;
     OnyxUtils.callbackToStateMapping[connectionID].connectionID = connectionID;
@@ -100,15 +105,15 @@ function connect<TKey extends OnyxKey>(options: ConnectOptions<TKey>): number {
             // If the mapping is connected to an onyx key that is not a collection
             // we can skip the call to getAllKeys() and return an array with a single item
             if (Boolean(mapping.key) && typeof mapping.key === 'string' && !mapping.key.endsWith('_') && cache.storageKeys.has(mapping.key)) {
-                return [mapping.key];
+                return new Set([mapping.key]);
             }
             return OnyxUtils.getAllKeys();
         })
         .then((keys) => {
             // We search all the keys in storage to see if any are a "match" for the subscriber we are connecting so that we
             // can send data back to the subscriber. Note that multiple keys can match as a subscriber could either be
             // subscribed to a "collection key" or a single key.
-            const matchingKeys = keys.filter((key) => OnyxUtils.isKeyMatch(mapping.key, key));
+            const matchingKeys = Array.from(keys).filter((key) => OnyxUtils.isKeyMatch(mapping.key, key));
 
             // If the key being connected to does not exist we initialize the value with null. For subscribers that connected
             // directly via connect() they will simply get a null value sent to them without any information about which key matched
@@ -387,8 +392,8 @@ function mergeCollection<TKey extends CollectionKeyBase, TMap>(collectionKey: TK
             return true;
         });
 
-        const existingKeys = keys.filter((key) => persistedKeys.includes(key));
-        const newKeys = keys.filter((key) => !persistedKeys.includes(key));
+        const existingKeys = keys.filter((key) => persistedKeys.has(key));
+        const newKeys = keys.filter((key) => !persistedKeys.has(key));
 
         const existingKeyCollection = existingKeys.reduce((obj: NullableKeyValueMapping, key) => {
             // eslint-disable-next-line no-param-reassign

lib/OnyxUtils.d.ts

@@ -66,7 +66,7 @@ declare function get(key: OnyxKey): Promise<OnyxValue<OnyxKey>>;
 /**
  * Returns current key names stored in persisted storage
  */
-declare function getAllKeys(): Promise<OnyxKey[]>;
+declare function getAllKeys(): Promise<Set<string>>;
 
 /**
  * Checks to see if the a subscriber's supplied key

lib/OnyxUtils.js

@@ -41,7 +41,7 @@ let evictionAllowList = [];
 const evictionBlocklist = {};
 
 // Optional user-provided key value states set when Onyx initializes or clears
-let defaultKeyStates = {};
+const defaultKeyStates = {};
 
 let batchUpdatesPromise = null;
 let batchUpdatesQueue = [];
@@ -67,7 +67,7 @@ function initStoreValues(keys, initialKeyStates, safeEvictionKeys) {
     );
 
     // Set our default key states to use when initializing and clearing Onyx data
-    defaultKeyStates = initialKeyStates;
+    _.assign(defaultKeyStates, initialKeyStates);
 
     DevTools.initState(initialKeyStates);
 

lib/types.ts

@@ -291,7 +291,7 @@ type BaseConnectOptions = {
 type ConnectOptions<TKey extends OnyxKey> = BaseConnectOptions &
     (
         | {
-              key: TKey extends CollectionKey ? TKey : never;
+              key: TKey extends CollectionKeyBase ? TKey : never;
               callback?: (value: OnyxCollection<KeyValueMapping[TKey]>) => void;
               waitForCollectionCallback: true;
           }

lib/useOnyx.ts

@@ -171,7 +171,7 @@ function useOnyx<TKey extends OnyxKey, TReturnValue = OnyxValue<TKey>>(key: TKey
         }
 
         if (!OnyxUtils.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 OnyxUtils.init({safeEvictionKeys: []}).`);
+            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 (options.canEvict) {

lib/withOnyx.js

@@ -9,6 +9,7 @@ import _ from 'underscore';
 import Onyx from './Onyx';
 import * as Str from './Str';
 import utils from './utils';
+import OnyxUtils from './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.
@@ -58,7 +59,7 @@ export default function (mapOnyxToState, shouldDelayUpdates = false) {
                     mapOnyxToState,
                     (resultObj, mapping, propertyName) => {
                         const key = Str.result(mapping.key, props);
-                        let value = Onyx.tryGetCachedValue(key, mapping);
+                        let value = OnyxUtils.tryGetCachedValue(key, mapping);
                         if (!value && mapping.initialValue) {
                             value = mapping.initialValue;
                         }
@@ -74,7 +75,7 @@ export default function (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.hasPendingMergeForKey(key)) || mapping.allowStaleData) {
+                        if ((value !== undefined && !OnyxUtils.hasPendingMergeForKey(key)) || mapping.allowStaleData) {
                             // eslint-disable-next-line no-param-reassign
                             resultObj[propertyName] = value;
                         }
@@ -256,14 +257,14 @@ export default function (mapOnyxToState, shouldDelayUpdates = false) {
                     const canEvict = Str.result(mapping.canEvict, this.props);
                     const key = Str.result(mapping.key, this.props);
 
-                    if (!Onyx.isSafeEvictionKey(key)) {
+                    if (!OnyxUtils.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.removeFromEvictionBlockList(key, mapping.connectionID);
+                        OnyxUtils.removeFromEvictionBlockList(key, mapping.connectionID);
                     } else {
-                        Onyx.addToEvictionBlockList(key, mapping.connectionID);
+                        OnyxUtils.addToEvictionBlockList(key, mapping.connectionID);
                     }
                 });
             }

tests/unit/onyxTest.js

@@ -1,6 +1,7 @@
 import _ from 'underscore';
 import Onyx from '../../lib';
 import waitForPromisesToResolve from '../utils/waitForPromisesToResolve';
+import OnyxUtils from '../../lib/OnyxUtils';
 
 const ONYX_KEYS = {
     TEST_KEY: 'test',
@@ -38,7 +39,7 @@ describe('Onyx', () => {
 
     it('should remove key value from OnyxCache/Storage when set is called with null value', () =>
         Onyx.set(ONYX_KEYS.OTHER_TEST, 42)
-            .then(() => Onyx.getAllKeys())
+            .then(() => OnyxUtils.getAllKeys())
             .then((keys) => {
                 expect(keys.has(ONYX_KEYS.OTHER_TEST)).toBe(true);
                 return Onyx.set(ONYX_KEYS.OTHER_TEST, null);
@@ -48,7 +49,7 @@ describe('Onyx', () => {
                 expect(cache.getAllKeys().size).toBe(0);
 
                 // When cache keys length is 0, we fetch the keys from storage.
-                return Onyx.getAllKeys();
+                return OnyxUtils.getAllKeys();
             })
             .then((keys) => {
                 expect(keys.has(ONYX_KEYS.OTHER_TEST)).toBe(false);